update tests and dispatcher for DifferenceBetween

Author: vfrank66

interpreter/operator_dispatcher.go

@@ -1032,6 +1032,14 @@ func (i *interpreter) binaryOverloads(m model.IBinaryExpression) ([]convert.Over
 				Operands: []types.IType{types.DateTime, types.DateTime},
 				Result:   evalDifferenceBetweenDateTime,
 			},
+			{
+				Operands: []types.IType{types.DateTime, types.Date},
+				Result:   evalDifferenceBetweenDateTime,
+			},
+			{
+				Operands: []types.IType{types.Date, types.DateTime},
+				Result:   evalDifferenceBetweenDateTime,
+			},
 		}, nil
 	case *model.In:
 		// TODO(b/301606416): Support all other In operator overloads.

tests/enginetests/operator_clinical_test.go

@@ -29,122 +29,6 @@ import (
 	"google.golang.org/protobuf/testing/protocmp"
 )
 
-func TestCalculateAge(t *testing.T) {
-	tests := []struct {
-		name       string
-		cql        string
-		wantModel  model.IExpression
-		wantResult result.Value
-	}{
-		// Age calculation functions - Note that these use the default evaluation timestamp
-		{
-			name: "AgeInYears Date",
-			cql:  "AgeInYears()",
-			wantModel: &model.CalculateAge{
-				Precision: model.YEAR,
-				UnaryExpression: &model.UnaryExpression{
-					Expression: model.ResultType(types.Integer),
-					Operand: &model.ToDateTime{
-						UnaryExpression: &model.UnaryExpression{
-							Expression: model.ResultType(types.DateTime),
-							Operand: &model.Property{
-								Expression: model.ResultType(types.Date),
-								Source: &model.Property{
-									Expression: model.ResultType(&types.Named{TypeName: "FHIR.date"}),
-									Source: &model.ExpressionRef{
-										Expression: model.ResultType(&types.Named{TypeName: "FHIR.Patient"}),
-										Name:       "Patient",
-									},
-									Path: "birthDate",
-								},
-								Path: "value",
-							},
-						},
-					},
-				},
-			},
-			wantResult: newOrFatal(t, 75), // The test patient birthday is 1950-01-01
-		},
-		{
-			name:       "AgeInMonths Date",
-			cql:        "AgeInMonths()",
-			wantResult: newOrFatal(t, 903), // 75 years * 12 months/year, approximately
-		},
-		{
-			name:       "AgeInWeeks Date",
-			cql:        "AgeInWeeks()",
-			wantResult: newOrFatal(t, 3928), // 75 years * 52 weeks/year, approximately
-		},
-		{
-			name:       "AgeInDays Date",
-			cql:        "AgeInDays()",
-			wantResult: newOrFatal(t, 27500), // 75 years * 365.25 days/year, approximately
-		},
-		{
-			name:       "AgeInHours Date",
-			cql:        "AgeInHours()",
-			wantResult: newOrFatal(t, 660000), // 75 years * 365.25 days/year * 24 hours/day, approximately
-		},
-		{
-			name:       "AgeInMinutes Date",
-			cql:        "AgeInMinutes()",
-			wantResult: newOrFatal(t, 39600000), // 75 years * 365.25 days/year * 24 hours/day * 60 minutes/hour, approximately
-		},
-		{
-			name:       "AgeInSeconds Date",
-			cql:        "AgeInSeconds()",
-			wantResult: newOrFatal(t, 2376000000), // 75 years * 365.25 days/year * 24 hours/day * 60 minutes/hour * 60 seconds/minute, approximately
-		},
-		// Custom birth date tests (using the evaluation time of 2025-04-16)
-		{
-			name:       "AgeInYears with explicit Date",
-			cql:        "CalculateAgeInYears(@1981-06-15)",
-			wantResult: newOrFatal(t, 43), // Age from 1981-06-15 to test time (2025-04-16)
-		},
-		{
-			name:       "AgeInMonths with explicit Date",
-			cql:        "CalculateAgeInMonths(@2022-06-15)",
-			wantResult: newOrFatal(t, 34), // Age from 2022-06-15 to test time (2025-04-16)
-		},
-		{
-			name:       "AgeInDays with explicit DateTime",
-			cql:        "CalculateAgeInDays(@2023-06-15T10:01:01.000Z)",
-			wantResult: newOrFatal(t, 671), // Days from 2023-06-15 to test time (2025-04-16)
-		},
-		{
-			name:       "AgeInHours with explicit DateTime",
-			cql:        "CalculateAgeInHours(@2025-04-15T10:01:01.000Z)",
-			wantResult: newOrFatal(t, 24), // Hours from 2025-04-15 to test time (2025-04-16)
-		},
-		// Null input
-		{
-			name:       "CalculateAgeInYears with null",
-			cql:        "CalculateAgeInYears(null as Date)",
-			wantResult: newOrFatal(t, nil),
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			p := newFHIRParser(t)
-			parsedLibs, err := p.Libraries(context.Background(), wrapInLib(t, tc.cql), parser.Config{})
-			if err != nil {
-				t.Fatalf("Parse returned unexpected error: %v", err)
-			}
-			if diff := cmp.Diff(tc.wantModel, getTESTRESULTModel(t, parsedLibs)); tc.wantModel != nil && diff != "" {
-				t.Errorf("Parse diff (-want +got):\n%s", diff)
-			}
-
-			results, err := interpreter.Eval(context.Background(), parsedLibs, defaultInterpreterConfig(t, p))
-			if err != nil {
-				t.Fatalf("Eval returned unexpected error: %v", err)
-			}
-			if diff := cmp.Diff(tc.wantResult, getTESTRESULT(t, results), protocmp.Transform()); diff != "" {
-				t.Errorf("Eval diff (-want +got)\n%v", diff)
-			}
-		})
-	}
-}
 
 func TestCalculateAgeAt(t *testing.T) {
 	tests := []struct {

tests/enginetests/operator_datetime_test.go

@@ -379,12 +379,12 @@ func TestDateTimeOperatorDifferenceBetween(t *testing.T) {
 		},
 		{
 			name:       "difference in years between null and @2022 returns null",
-			cql:        "difference in years between null  and @2022",
+			cql:        "difference in years between (null as Date)  and @2022",
 			wantResult: newOrFatal(t, nil),
 		},
 		{
 			name:       "difference in years between @2020 and null returns null",
-			cql:        "difference in years between @2020 and null",
+			cql:        "difference in years between @2020 and (null as Date)",
 			wantResult: newOrFatal(t, nil),
 		},
 		{