pre-commit fixes

Author: ci.datadog-api-spec

src/main/java/com/datadog/api/client/v1/model/DistributionPointItem.java

@@ -147,7 +147,8 @@ public DistributionPointItem deserialize(JsonParser jp, DeserializationContext c
           }
         }
         if (attemptParsing) {
-          tmp = tree.traverse(jp.getCodec()).readValueAs(List.class);
+          // Using TypeReference for parameterized type List<Double> (Java 8 compatible)
+          tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<List<Double>>() {});
           // TODO: there is no validation against JSON schema constraints
           // (min, max, enum, pattern...), this does not perform a strict JSON
           // validation, which means the 'match' count may be higher than it should be.

src/main/java/com/datadog/api/client/v1/model/SharedDashboardInvitesData.java

@@ -153,7 +153,11 @@ public SharedDashboardInvitesData deserialize(JsonParser jp, DeserializationCont
           }
         }
         if (attemptParsing) {
-          tmp = tree.traverse(jp.getCodec()).readValueAs(List.class);
+          // Using TypeReference for parameterized type List<SharedDashboardInvitesDataObject> (Java
+          // 8 compatible)
+          tmp =
+              tree.traverse(jp.getCodec())
+                  .readValueAs(new TypeReference<List<SharedDashboardInvitesDataObject>>() {});
           // TODO: there is no validation against JSON schema constraints
           // (min, max, enum, pattern...), this does not perform a strict JSON
           // validation, which means the 'match' count may be higher than it should be.

src/main/java/com/datadog/api/client/v2/model/ActionQuerySpecInputs.java

@@ -146,7 +146,9 @@ public ActionQuerySpecInputs deserialize(JsonParser jp, DeserializationContext c
           }
         }
         if (attemptParsing) {
-          tmp = tree.traverse(jp.getCodec()).readValueAs(Map.class);
+          // Using TypeReference for parameterized type Map<String, Object> (Java 8 compatible)
+          tmp =
+              tree.traverse(jp.getCodec()).readValueAs(new TypeReference<Map<String, Object>>() {});
           // TODO: there is no validation against JSON schema constraints
           // (min, max, enum, pattern...), this does not perform a strict JSON
           // validation, which means the 'match' count may be higher than it should be.

src/main/java/com/datadog/api/client/v2/model/CIAppCreatePipelineEventRequestDataSingleOrArray.java

@@ -165,7 +165,11 @@ public CIAppCreatePipelineEventRequestDataSingleOrArray deserialize(
           }
         }
         if (attemptParsing) {
-          tmp = tree.traverse(jp.getCodec()).readValueAs(List.class);
+          // Using TypeReference for parameterized type List<CIAppCreatePipelineEventRequestData>
+          // (Java 8 compatible)
+          tmp =
+              tree.traverse(jp.getCodec())
+                  .readValueAs(new TypeReference<List<CIAppCreatePipelineEventRequestData>>() {});
           // TODO: there is no validation against JSON schema constraints
           // (min, max, enum, pattern...), this does not perform a strict JSON
           // validation, which means the 'match' count may be higher than it should be.

src/test/java/com/datadog/api/compatibility/DiamondOperatorCompilationTest.java

@@ -1,169 +1,170 @@
 package com.datadog.api.compatibility;
 
+import static org.junit.Assert.*;
+
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.Test;
-
 import java.io.IOException;
 import java.util.List;
-
-import static org.junit.Assert.*;
+import org.junit.Test;
 
 /**
- * CRITICAL TEST: This demonstrates the exact Java 8 compilation issue that PR #4191 would have caused.
+ * CRITICAL TEST: This demonstrates the exact Java 8 compilation issue that PR #4191 would have
+ * caused.
  *
- * This test contains BOTH the problematic pattern AND the fixed pattern to prove our solution works.
+ * <p>This test contains BOTH the problematic pattern AND the fixed pattern to prove our solution
+ * works.
  */
 public class DiamondOperatorCompilationTest {
 
-    private final ObjectMapper objectMapper = new ObjectMapper();
+  private final ObjectMapper objectMapper = new ObjectMapper();
+
+  @Test
+  public void testJava8DiamondOperatorIssueReproduction() throws IOException {
+    // This test reproduces the EXACT issue from PR #4191
+
+    String jsonArray = "[{\"email\": \"test@example.com\"}, {\"role\": \"viewer\"}]";
+    JsonNode tree = objectMapper.readTree(jsonArray);
 
-    @Test
-    public void testJava8DiamondOperatorIssueReproduction() throws IOException {
-        // This test reproduces the EXACT issue from PR #4191
+    // ❌ PROBLEMATIC PATTERN (would fail compilation in Java 8):
+    // The following line would cause this compilation error:
+    // "cannot infer type arguments for com.fasterxml.jackson.core.type.TypeReference<T>
+    //  reason: '<>' with anonymous inner classes is not supported in -source 8"
+    //
+    // Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<>() {});
+    //                                                                           ^^
+    //                                                               Diamond operator fails!
 
-        String jsonArray = "[{\"email\": \"test@example.com\"}, {\"role\": \"viewer\"}]";
-        JsonNode tree = objectMapper.readTree(jsonArray);
+    // ✅ FIXED PATTERN (works in Java 8):
+    Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Object>>() {});
 
-        // ❌ PROBLEMATIC PATTERN (would fail compilation in Java 8):
-        // The following line would cause this compilation error:
-        // "cannot infer type arguments for com.fasterxml.jackson.core.type.TypeReference<T>
-        //  reason: '<>' with anonymous inner classes is not supported in -source 8"
-        //
-        // Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<>() {});
-        //                                                                           ^^
-        //                                                               Diamond operator fails!
+    assertNotNull(tmp);
+    assertTrue("Should deserialize successfully with explicit type", tmp instanceof List);
 
-        // ✅ FIXED PATTERN (works in Java 8):
-        Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Object>>() {});
+    @SuppressWarnings("unchecked")
+    List<Object> result = (List<Object>) tmp;
+    assertEquals("Should have 2 elements", 2, result.size());
+  }
 
-        assertNotNull(tmp);
-        assertTrue("Should deserialize successfully with explicit type", tmp instanceof List);
+  @Test
+  public void testTemplateFixSimulation() throws IOException {
+    // This simulates what our template fix does:
+    // Detects parameterized types and uses explicit TypeReference
 
-        @SuppressWarnings("unchecked")
-        List<Object> result = (List<Object>) tmp;
-        assertEquals("Should have 2 elements", 2, result.size());
-    }
+    String jsonData = "[1.5, 2.0, 3.7]"; // Numbers (like DistributionPointItem)
+    JsonNode tree = objectMapper.readTree(jsonData);
 
-    @Test
-    public void testTemplateFixSimulation() throws IOException {
-        // This simulates what our template fix does:
-        // Detects parameterized types and uses explicit TypeReference
+    // Template logic simulation:
+    String dataType = "List<Double>";
+    String unParameterizedDataType = "Double"; // This would be different, so use TypeReference
 
-        String jsonData = "[1.5, 2.0, 3.7]"; // Numbers (like DistributionPointItem)
-        JsonNode tree = objectMapper.readTree(jsonData);
+    boolean isParameterized = !dataType.equals(unParameterizedDataType);
+    assertTrue("Template should detect this as parameterized", isParameterized);
 
-        // Template logic simulation:
-        String dataType = "List<Double>";
-        String unParameterizedDataType = "Double"; // This would be different, so use TypeReference
+    // Because it's parameterized, template generates this (FIXED pattern):
+    Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Double>>() {});
+    // Instead of this (BROKEN pattern that would fail):
+    // Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<>() {});
 
-        boolean isParameterized = !dataType.equals(unParameterizedDataType);
-        assertTrue("Template should detect this as parameterized", isParameterized);
+    assertNotNull(tmp);
+    assertTrue(tmp instanceof List);
 
-        // Because it's parameterized, template generates this (FIXED pattern):
-        Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Double>>() {});
-        // Instead of this (BROKEN pattern that would fail):
-        // Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<>() {});
+    @SuppressWarnings("unchecked")
+    List<Double> result = (List<Double>) tmp;
+    assertEquals(3, result.size());
+    assertEquals(1.5, result.get(0), 0.001);
+  }
 
-        assertNotNull(tmp);
-        assertTrue(tmp instanceof List);
+  @Test
+  public void testOriginalSharedDashboardInvitesDataScenario() throws IOException {
+    // This recreates the exact failing scenario from SharedDashboardInvitesData.java:138
 
-        @SuppressWarnings("unchecked")
-        List<Double> result = (List<Double>) tmp;
-        assertEquals(3, result.size());
-        assertEquals(1.5, result.get(0), 0.001);
-    }
+    String jsonInvites = "[{\"email\":\"user@example.com\",\"role\":\"viewer\"}]";
+    JsonNode tree = objectMapper.readTree(jsonInvites);
 
-    @Test
-    public void testOriginalSharedDashboardInvitesDataScenario() throws IOException {
-        // This recreates the exact failing scenario from SharedDashboardInvitesData.java:138
+    // BEFORE our fix (would cause Java 8 compilation failure):
+    // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
 
-        String jsonInvites = "[{\"email\":\"user@example.com\",\"role\":\"viewer\"}]";
-        JsonNode tree = objectMapper.readTree(jsonInvites);
+    // AFTER our fix (Java 8 compatible):
+    Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Object>>() {});
 
-        // BEFORE our fix (would cause Java 8 compilation failure):
-        // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
+    assertNotNull("Should deserialize invite data", tmp);
+    assertTrue("Should be a List", tmp instanceof List);
 
-        // AFTER our fix (Java 8 compatible):
-        Object tmp = tree.traverse(objectMapper)
-            .readValueAs(new TypeReference<List<Object>>() {});
+    @SuppressWarnings("unchecked")
+    List<Object> invites = (List<Object>) tmp;
+    assertEquals("Should have one invite", 1, invites.size());
+  }
 
-        assertNotNull("Should deserialize invite data", tmp);
-        assertTrue("Should be a List", tmp instanceof List);
+  @Test
+  public void testOriginalDistributionPointItemScenario() throws IOException {
+    // This recreates the exact failing scenario from DistributionPointItem.java:132
 
-        @SuppressWarnings("unchecked")
-        List<Object> invites = (List<Object>) tmp;
-        assertEquals("Should have one invite", 1, invites.size());
-    }
+    String jsonPoints = "[1.0, 2.5, 3.14]"; // Distribution points as numbers
+    JsonNode tree = objectMapper.readTree(jsonPoints);
 
-    @Test
-    public void testOriginalDistributionPointItemScenario() throws IOException {
-        // This recreates the exact failing scenario from DistributionPointItem.java:132
+    // BEFORE our fix (would cause Java 8 compilation failure):
+    // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
 
-        String jsonPoints = "[1.0, 2.5, 3.14]";  // Distribution points as numbers
-        JsonNode tree = objectMapper.readTree(jsonPoints);
+    // AFTER our fix (Java 8 compatible):
+    Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Double>>() {});
 
-        // BEFORE our fix (would cause Java 8 compilation failure):
-        // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
+    assertNotNull("Should deserialize distribution points", tmp);
+    assertTrue("Should be a List", tmp instanceof List);
 
-        // AFTER our fix (Java 8 compatible):
-        Object tmp = tree.traverse(objectMapper)
-            .readValueAs(new TypeReference<List<Double>>() {});
+    @SuppressWarnings("unchecked")
+    List<Double> points = (List<Double>) tmp;
+    assertEquals("Should have 3 points", 3, points.size());
+    assertEquals("First point should be 1.0", 1.0, points.get(0), 0.001);
+  }
 
-        assertNotNull("Should deserialize distribution points", tmp);
-        assertTrue("Should be a List", tmp instanceof List);
+  @Test
+  public void testCustomAttributeValuesUnionScenario() throws IOException {
+    // This recreates what CustomAttributeValuesUnion.java:133 would have been
 
-        @SuppressWarnings("unchecked")
-        List<Double> points = (List<Double>) tmp;
-        assertEquals("Should have 3 points", 3, points.size());
-        assertEquals("First point should be 1.0", 1.0, points.get(0), 0.001);
-    }
-
-    @Test
-    public void testCustomAttributeValuesUnionScenario() throws IOException {
-        // This recreates what CustomAttributeValuesUnion.java:133 would have been
-
-        String jsonValues = "[\"string_value\", 42, {\"object\": \"value\"}]"; // Mixed values
-        JsonNode tree = objectMapper.readTree(jsonValues);
-
-        // BEFORE our fix (would cause Java 8 compilation failure):
-        // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
+    String jsonValues = "[\"string_value\", 42, {\"object\": \"value\"}]"; // Mixed values
+    JsonNode tree = objectMapper.readTree(jsonValues);
 
-        // AFTER our fix (Java 8 compatible):
-        Object tmp = tree.traverse(objectMapper)
-            .readValueAs(new TypeReference<List<Object>>() {});
+    // BEFORE our fix (would cause Java 8 compilation failure):
+    // tmp = tree.traverse(jp.getCodec()).readValueAs(new TypeReference<>() {});
+
+    // AFTER our fix (Java 8 compatible):
+    Object tmp = tree.traverse(objectMapper).readValueAs(new TypeReference<List<Object>>() {});
 
-        assertNotNull("Should deserialize custom attribute values", tmp);
-        assertTrue("Should be a List", tmp instanceof List);
+    assertNotNull("Should deserialize custom attribute values", tmp);
+    assertTrue("Should be a List", tmp instanceof List);
 
-        @SuppressWarnings("unchecked")
-        List<Object> values = (List<Object>) tmp;
-        assertEquals("Should have 3 values", 3, values.size());
-    }
+    @SuppressWarnings("unchecked")
+    List<Object> values = (List<Object>) tmp;
+    assertEquals("Should have 3 values", 3, values.size());
+  }
 
-    @Test
-    public void testCompilationDifferenceDocumentation() {
-        // This test documents the exact difference between failing and working code
+  @Test
+  public void testCompilationDifferenceDocumentation() {
+    // This test documents the exact difference between failing and working code
 
-        // ❌ FAILS in Java 8 (diamond operator with anonymous inner class):
-        String failingPattern = "new TypeReference<>() {}";
+    // ❌ FAILS in Java 8 (diamond operator with anonymous inner class):
+    String failingPattern = "new TypeReference<>() {}";
 
-        // ✅ WORKS in Java 8 (explicit type parameters):
-        String workingPattern1 = "new TypeReference<List<String>>() {}";
-        String workingPattern2 = "new TypeReference<List<Object>>() {}";
-        String workingPattern3 = "new TypeReference<List<Double>>() {}";
+    // ✅ WORKS in Java 8 (explicit type parameters):
+    String workingPattern1 = "new TypeReference<List<String>>() {}";
+    String workingPattern2 = "new TypeReference<List<Object>>() {}";
+    String workingPattern3 = "new TypeReference<List<Double>>() {}";
 
-        // Verify the patterns
-        assertTrue("Failing pattern uses diamond operator", failingPattern.contains("<>"));
+    // Verify the patterns
+    assertTrue("Failing pattern uses diamond operator", failingPattern.contains("<>"));
 
-        assertFalse("Working pattern 1 should not use diamond operator", workingPattern1.contains("<>"));
-        assertFalse("Working pattern 2 should not use diamond operator", workingPattern2.contains("<>"));
-        assertFalse("Working pattern 3 should not use diamond operator", workingPattern3.contains("<>"));
+    assertFalse(
+        "Working pattern 1 should not use diamond operator", workingPattern1.contains("<>"));
+    assertFalse(
+        "Working pattern 2 should not use diamond operator", workingPattern2.contains("<>"));
+    assertFalse(
+        "Working pattern 3 should not use diamond operator", workingPattern3.contains("<>"));
 
-        // All working patterns have explicit types
-        assertTrue("Pattern 1 has explicit type", workingPattern1.contains("List<String>"));
-        assertTrue("Pattern 2 has explicit type", workingPattern2.contains("List<Object>"));
-        assertTrue("Pattern 3 has explicit type", workingPattern3.contains("List<Double>"));
-    }
-}
+    // All working patterns have explicit types
+    assertTrue("Pattern 1 has explicit type", workingPattern1.contains("List<String>"));
+    assertTrue("Pattern 2 has explicit type", workingPattern2.contains("List<Object>"));
+    assertTrue("Pattern 3 has explicit type", workingPattern3.contains("List<Double>"));
+  }
+}