Function TestReducerCollectToMap

functional/functional_test.go:890–981

(t *testing.T)

}

func TestReducerCollectToMap(t *testing.T) {
	tests := []struct {
		name string
		rows [][]ast.Constant
	}{
		{
			name: "simple key-value pairs",
			rows: [][]ast.Constant{
				{name("/key1"), ast.Number(1)},
				{name("/key2"), ast.Number(2)},
				{name("/key3"), ast.Number(3)},
			},
		},
		{
			name: "duplicate keys (should use first occurrence)",
			rows: [][]ast.Constant{
				{name("/key1"), ast.Number(1)},
				{name("/key2"), ast.Number(2)},
				{name("/key1"), ast.Number(10)}, // duplicate key, should be ignored
			},
		},
		{
			name: "empty input",
			rows: [][]ast.Constant{},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			var rows []ast.ConstSubstList
			for _, row := range test.rows {
				if len(row) > 0 {
					rows = append(rows, makeConstSubstList(makeVarList(len(row)), row))
				}
			}

			// CollectToMap expects exactly 2 arguments (key variable, value variable)
			args := []ast.BaseTerm{ast.Variable{"X0"}, ast.Variable{"X1"}}
			expr := ast.ApplyFn{symbols.CollectToMap, args}
			got, err := EvalReduceFn(expr, rows)
			if err != nil {
				t.Fatalf("EvalReduceFn(%v,%v) failed with %v", expr, rows, err)
			}

			// Validate that we got a map
			if got.Type != ast.MapShape {
				t.Errorf("EvalReduceFn(%v,%v) returned %v (type %v), expected map", expr, rows, got, got.Type)
				return
			}

			// For empty input, expect empty map
			if len(test.rows) == 0 {
				if !got.IsMapNil() {
					t.Errorf("EvalReduceFn with empty input should return empty map, got %v", got)
				}
				return
			}