fix(dynamodb-enhanced): Fix NPE in EnhancedType for null and wildcard types (#6745)

* fix(dynamodb-enhanced): Fix NPE in ConverterUtils and EnhancedType for null values and wildcard types

- Add null checks to ConverterUtils.validateDouble() and validateFloat() to prevent NPE when input is null
- Add null check for rawClass in EnhancedType.hashCode() and equals() to support wildcard types (List<?>)
- Add comprehensive unit tests for null handling

Fixes #6639
Fixes #5890

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(dynamodb-enhanced): Add toString() NPE fix, split out ConverterUtils changes

- Add null check in innerToString() for wildcard types (rawClass is null)
- Add test for toString() with wildcard types
- Remove ConverterUtils changes (to be submitted as separate PR per maintainer request)
- Update changelog to reflect EnhancedType-only changes

* test: add test for wildcard vs non-wildcard equality comparison

Addresses review feedback to cover the ternary logic in equals() when
comparing a wildcard type (rawClass=null) against a non-wildcard type
(rawClass!=null). Tests both comparison directions.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: abhu85 <abhu85@users.noreply.github.com>

Author: abhu85

.changes/next-release/bugfix-AmazonDynamoDBEnhancedClient-npe-fixes.json

@@ -0,0 +1,6 @@
+{
+    "type": "bugfix",
+    "category": "Amazon DynamoDB Enhanced Client",
+    "contributor": "",
+    "description": "Fix NullPointerException in `EnhancedType.hashCode()`, `EnhancedType.equals()`, and `EnhancedType.toString()` when using wildcard types."
+}

services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/EnhancedType.java

@@ -541,14 +541,17 @@ private List<EnhancedType<?>> loadTypeParameters(Type type) {
 
     private StringBuilder innerToString() {
         StringBuilder result = new StringBuilder();
-        result.append(rawClass.getTypeName());
+        if (isWildcard) {
+            result.append("?");
+        } else {
+            result.append(rawClass.getTypeName());
 
-        if (null != rawClassParameters && !rawClassParameters.isEmpty()) {
-            result.append("<");
-            result.append(rawClassParameters.stream().map(EnhancedType::innerToString).collect(Collectors.joining(", ")));
-            result.append(">");
+            if (null != rawClassParameters && !rawClassParameters.isEmpty()) {
+                result.append("<");
+                result.append(rawClassParameters.stream().map(EnhancedType::innerToString).collect(Collectors.joining(", ")));
+                result.append(">");
+            }
         }
-
         return result;
     }
 
@@ -566,7 +569,7 @@ public boolean equals(Object o) {
         if (isWildcard != enhancedType.isWildcard) {
             return false;
         }
-        if (!rawClass.equals(enhancedType.rawClass)) {
+        if (rawClass != null ? !rawClass.equals(enhancedType.rawClass) : enhancedType.rawClass != null) {
             return false;
         }
         if (rawClassParameters != null ? !rawClassParameters.equals(enhancedType.rawClassParameters) :
@@ -584,7 +587,7 @@ public boolean equals(Object o) {
     @Override
     public int hashCode() {
         int result = (isWildcard ? 1 : 0);
-        result = 31 * result + rawClass.hashCode();
+        result = 31 * result + (rawClass != null ? rawClass.hashCode() : 0);
         result = 31 * result + (rawClassParameters != null ? rawClassParameters.hashCode() : 0);
         result = 31 * result + (tableSchema != null ? tableSchema.hashCode() : 0);
         result = 31 * result + (documentConfiguration != null ? documentConfiguration.hashCode() : 0);

services-custom/dynamodb-enhanced/src/test/java/software/amazon/awssdk/enhanced/dynamodb/EnhancedTypeTest.java

@@ -239,6 +239,57 @@ public void documentOf_withEnhancedTypeConfiguration() {
         assertThat(type.documentConfiguration().get().preserveEmptyObject()).isTrue();
     }
 
+    @Test
+    public void wildcardType_hashCode_doesNotRaiseNPE() {
+        // When using a wildcard type like List<?>, the type parameter is a wildcard
+        // with rawClass = null. hashCode() should handle this without NPE.
+        EnhancedType<List<?>> listWithWildcard = new EnhancedType<List<?>>(){};
+        EnhancedType<?> wildcardParam = listWithWildcard.rawClassParameters().get(0);
+
+        // This should not throw NPE
+        assertThatCode(() -> wildcardParam.hashCode()).doesNotThrowAnyException();
+    }
+
+    @Test
+    public void wildcardType_equals_handlesNullRawClass() {
+        // Wildcard types should be comparable via equals without NPE
+        EnhancedType<List<?>> listWithWildcard1 = new EnhancedType<List<?>>(){};
+        EnhancedType<List<?>> listWithWildcard2 = new EnhancedType<List<?>>(){};
+
+        EnhancedType<?> wildcard1 = listWithWildcard1.rawClassParameters().get(0);
+        EnhancedType<?> wildcard2 = listWithWildcard2.rawClassParameters().get(0);
+
+        // Wildcards should be equal to each other
+        assertThat(wildcard1).isEqualTo(wildcard2);
+        assertThat(wildcard1.hashCode()).isEqualTo(wildcard2.hashCode());
+    }
+
+    @Test
+    public void wildcardType_equals_notEqualToNonWildcard() {
+        // A wildcard type (rawClass=null) should not be equal to a non-wildcard type (rawClass!=null)
+        EnhancedType<List<?>> listWithWildcard = new EnhancedType<List<?>>(){};
+        EnhancedType<?> wildcardType = listWithWildcard.rawClassParameters().get(0);
+        EnhancedType<String> nonWildcardType = EnhancedType.of(String.class);
+
+        // Wildcard vs non-wildcard should not be equal (tests both comparison directions)
+        assertThat(wildcardType).isNotEqualTo(nonWildcardType);
+        assertThat(nonWildcardType).isNotEqualTo(wildcardType);
+    }
+
+    @Test
+    public void wildcardType_toString_doesNotRaiseNPE() {
+        // Wildcard types should be convertible to string without NPE
+        EnhancedType<List<?>> listWithWildcard = new EnhancedType<List<?>>(){};
+        EnhancedType<?> wildcardParam = listWithWildcard.rawClassParameters().get(0);
+
+        // This should not throw NPE and should return "?" for wildcard
+        assertThatCode(() -> wildcardParam.toString()).doesNotThrowAnyException();
+        assertThat(wildcardParam.toString()).isEqualTo("EnhancedType(?)");
+
+        // Also verify that the parent type renders correctly with wildcard
+        assertThat(listWithWildcard.toString()).isEqualTo("EnhancedType(java.util.List<?>)");
+    }
+
     public class InnerType {
     }