(improvement) harden RowData and improve NewWithError test coverage

- Add defensive guard in RowData() to detect actualColCount metadata
  inconsistency: returns a clear error instead of silently producing
  trailing zero-values or panicking on index-out-of-bounds.

- Set iter.err in column count mismatch guard to match error contract.

- Add overflow bounds checks before slice indexing to prevent panics.

- Add TypeFloat fast-path for map values in CollectionType.NewWithError()
  for both string-key and int-key maps, avoiding reflection for
  map[string]float32 and map[int]float32.

- Move TestNewWithErrorConsistentWithGoType from helpers_bench_test.go
  to marshal_test.go (with unit build tag) where it logically belongs.

- Add TestCollectionNewWithErrorConsistentWithGoType to verify that
  CollectionType.NewWithError() fast-paths stay in sync with goType()
  for list, set, and map types with common element/key combinations.

Signed-off-by: Yaniv Kaul <yaniv.kaul@scylladb.com>

Author: mykaul

helpers.go

@@ -376,6 +376,11 @@ func (iter *Iter) RowData() (RowData, error) {
 	idx := 0
 	for _, column := range iter.Columns() {
 		if c, ok := column.TypeInfo.(TupleTypeInfo); !ok {
+			if idx >= actualSize {
+				err := fmt.Errorf("gocql: column count overflow in RowData: metadata predicted %d columns but encountered more", actualSize)
+				iter.err = err
+				return RowData{}, err
+			}
 			val, err := column.TypeInfo.NewWithError()
 			if err != nil {
 				iter.err = err
@@ -386,6 +391,11 @@ func (iter *Iter) RowData() (RowData, error) {
 			idx++
 		} else {
 			for i, elem := range c.Elems {
+				if idx >= actualSize {
+					err := fmt.Errorf("gocql: column count overflow in RowData: metadata predicted %d columns but encountered more", actualSize)
+					iter.err = err
+					return RowData{}, err
+				}
 				columns[idx] = TupleColumnName(column.Name, i)
 				val, err := elem.NewWithError()
 				if err != nil {
@@ -398,6 +408,12 @@ func (iter *Iter) RowData() (RowData, error) {
 		}
 	}
 
+	if idx != actualSize {
+		err := fmt.Errorf("gocql: column count mismatch in RowData: metadata predicted %d columns but got %d", actualSize, idx)
+		iter.err = err
+		return RowData{}, err
+	}
+
 	rowData := RowData{
 		Columns: columns,
 		Values:  values,

helpers_bench_test.go

@@ -20,7 +20,6 @@ package gocql
 
 import (
 	"fmt"
-	"reflect"
 	"testing"
 )
 
@@ -228,61 +227,3 @@ func BenchmarkRowDataAllocation(b *testing.B) {
 		})
 	}
 }
-
-// TestNewWithErrorConsistentWithGoType verifies that the fast-path type mapping
-// in NativeType.NewWithError() stays consistent with the canonical goType() mapping.
-// This guards against future changes to one mapping that forget to update the other.
-func TestNewWithErrorConsistentWithGoType(t *testing.T) {
-	// All NativeType type codes that goType handles (excluding collection/tuple/UDT
-	// which are separate TypeInfo implementations).
-	nativeTypes := []Type{
-		TypeVarchar, TypeAscii, TypeText, TypeInet,
-		TypeBigInt, TypeCounter,
-		TypeTime,
-		TypeTimestamp,
-		TypeBlob,
-		TypeBoolean,
-		TypeFloat,
-		TypeDouble,
-		TypeInt,
-		TypeSmallInt,
-		TypeTinyInt,
-		TypeDecimal,
-		TypeUUID, TypeTimeUUID,
-		TypeVarint,
-		TypeDate,
-		TypeDuration,
-	}
-
-	for _, typ := range nativeTypes {
-		nt := NativeType{typ: typ, proto: protoVersion4}
-
-		// Get the fast-path result from NewWithError
-		fastVal, err := nt.NewWithError()
-		if err != nil {
-			t.Errorf("NewWithError(%s): unexpected error: %v", typ, err)
-			continue
-		}
-
-		// Get the canonical type from goType
-		canonicalType, err := goType(nt)
-		if err != nil {
-			t.Errorf("goType(%s): unexpected error: %v", typ, err)
-			continue
-		}
-
-		// NewWithError returns a pointer (reflect.New(typ).Interface()), so the
-		// underlying type is reflect.TypeOf(val).Elem()
-		fastType := reflect.TypeOf(fastVal)
-		if fastType.Kind() != reflect.Ptr {
-			t.Errorf("NewWithError(%s): expected pointer, got %s", typ, fastType.Kind())
-			continue
-		}
-		fastElemType := fastType.Elem()
-
-		if fastElemType != canonicalType {
-			t.Errorf("NewWithError(%s) fast-path type %s does not match goType() canonical type %s",
-				typ, fastElemType, canonicalType)
-		}
-	}
-}

marshal.go

@@ -1862,6 +1862,8 @@ func (t CollectionType) NewWithError() (interface{}, error) {
 						return new(map[string]string), nil
 					case TypeBoolean:
 						return new(map[string]bool), nil
+					case TypeFloat:
+						return new(map[string]float32), nil
 					case TypeDouble:
 						return new(map[string]float64), nil
 					case TypeUUID:
@@ -1875,6 +1877,8 @@ func (t CollectionType) NewWithError() (interface{}, error) {
 						return new(map[int]string), nil
 					case TypeInt:
 						return new(map[int]int), nil
+					case TypeFloat:
+						return new(map[int]float32), nil
 					}
 				}
 			}
@@ -1926,7 +1930,7 @@ func (t TupleTypeInfo) String() string {
 }
 
 func (t TupleTypeInfo) NewWithError() (interface{}, error) {
-	// Tuples scan into *[]interface{} (pointer to a slice of interface values).
+	// Tuples scan into *[]interface{} — no reflection needed.
 	return new([]interface{}), nil
 }
 

marshal_test.go

@@ -1035,3 +1035,152 @@ func bytesWithLength(data ...[]byte) []byte {
 	}
 	return ret
 }
+
+// TestNativeNewWithErrorConsistentWithGoType verifies that the fast-path type mapping
+// in NativeType.NewWithError() stays consistent with the canonical goType() mapping.
+// This guards against future changes to one mapping that forget to update the other.
+func TestNativeNewWithErrorConsistentWithGoType(t *testing.T) {
+	// All NativeType type codes that goType handles (excluding collection/tuple/UDT
+	// which are separate TypeInfo implementations).
+	nativeTypes := []Type{
+		TypeVarchar, TypeAscii, TypeText, TypeInet,
+		TypeBigInt, TypeCounter,
+		TypeTime,
+		TypeTimestamp,
+		TypeBlob,
+		TypeBoolean,
+		TypeFloat,
+		TypeDouble,
+		TypeInt,
+		TypeSmallInt,
+		TypeTinyInt,
+		TypeDecimal,
+		TypeUUID, TypeTimeUUID,
+		TypeVarint,
+		TypeDate,
+		TypeDuration,
+	}
+
+	for _, typ := range nativeTypes {
+		nt := NativeType{typ: typ, proto: protoVersion4}
+
+		// Get the fast-path result from NewWithError
+		fastVal, err := nt.NewWithError()
+		if err != nil {
+			t.Errorf("NewWithError(%s): unexpected error: %v", typ, err)
+			continue
+		}
+
+		// Get the canonical type from goType
+		canonicalType, err := goType(nt)
+		if err != nil {
+			t.Errorf("goType(%s): unexpected error: %v", typ, err)
+			continue
+		}
+
+		// NewWithError returns a pointer (reflect.New(typ).Interface()), so the
+		// underlying type is reflect.TypeOf(val).Elem()
+		fastType := reflect.TypeOf(fastVal)
+		if fastType.Kind() != reflect.Ptr {
+			t.Errorf("NewWithError(%s): expected pointer, got %s", typ, fastType.Kind())
+			continue
+		}
+		fastElemType := fastType.Elem()
+
+		if fastElemType != canonicalType {
+			t.Errorf("NewWithError(%s) fast-path type %s does not match goType() canonical type %s",
+				typ, fastElemType, canonicalType)
+		}
+	}
+}
+
+// TestCollectionNewWithErrorConsistentWithGoType verifies that the fast-path type mapping
+// in CollectionType.NewWithError() stays consistent with the canonical goType() mapping.
+func TestCollectionNewWithErrorConsistentWithGoType(t *testing.T) {
+	elemTypes := []Type{
+		TypeInt, TypeBigInt, TypeCounter,
+		TypeText, TypeVarchar, TypeAscii,
+		TypeBoolean,
+		TypeFloat, TypeDouble,
+		TypeUUID, TypeTimeUUID,
+		TypeTimestamp, TypeDate,
+		TypeSmallInt, TypeTinyInt,
+		TypeBlob,
+	}
+
+	// Test list and set types
+	for _, collTyp := range []Type{TypeList, TypeSet} {
+		for _, elemTyp := range elemTypes {
+			ct := CollectionType{
+				NativeType: NativeType{typ: collTyp, proto: protoVersion4},
+				Elem:       NativeType{typ: elemTyp, proto: protoVersion4},
+			}
+
+			fastVal, err := ct.NewWithError()
+			if err != nil {
+				t.Errorf("NewWithError(%s<%s>): unexpected error: %v", collTyp, elemTyp, err)
+				continue
+			}
+
+			canonicalType, err := goType(ct)
+			if err != nil {
+				t.Errorf("goType(%s<%s>): unexpected error: %v", collTyp, elemTyp, err)
+				continue
+			}
+
+			fastType := reflect.TypeOf(fastVal)
+			if fastType.Kind() != reflect.Ptr {
+				t.Errorf("NewWithError(%s<%s>): expected pointer, got %s", collTyp, elemTyp, fastType.Kind())
+				continue
+			}
+
+			if fastType.Elem() != canonicalType {
+				t.Errorf("NewWithError(%s<%s>) fast-path type %s does not match goType() canonical type %s",
+					collTyp, elemTyp, fastType.Elem(), canonicalType)
+			}
+		}
+	}
+
+	// Test map types with common key/value combinations
+	keyTypes := []Type{TypeText, TypeVarchar, TypeInt}
+	valTypes := []Type{
+		TypeInt, TypeBigInt,
+		TypeText, TypeVarchar,
+		TypeBoolean,
+		TypeFloat, TypeDouble,
+		TypeUUID,
+	}
+
+	for _, keyTyp := range keyTypes {
+		for _, valTyp := range valTypes {
+			ct := CollectionType{
+				NativeType: NativeType{typ: TypeMap, proto: protoVersion4},
+				Key:        NativeType{typ: keyTyp, proto: protoVersion4},
+				Elem:       NativeType{typ: valTyp, proto: protoVersion4},
+			}
+
+			fastVal, err := ct.NewWithError()
+			if err != nil {
+				t.Errorf("NewWithError(map<%s, %s>): unexpected error: %v", keyTyp, valTyp, err)
+				continue
+			}
+
+			canonicalType, err := goType(ct)
+			if err != nil {
+				t.Errorf("goType(map<%s, %s>): unexpected error: %v", keyTyp, valTyp, err)
+				continue
+			}
+
+			fastType := reflect.TypeOf(fastVal)
+			if fastType.Kind() != reflect.Ptr {
+				t.Errorf("NewWithError(map<%s, %s>): expected pointer, got %s", keyTyp, valTyp, fastType.Kind())
+				continue
+			}
+
+			if fastType.Elem() != canonicalType {
+				t.Errorf("NewWithError(map<%s, %s>) fast-path type %s does not match goType() canonical type %s",
+					keyTyp, valTyp, fastType.Elem(), canonicalType)
+			}
+		}
+	}
+}