Test aggregation metadata types matches function implementation

Add tests to ensure input, intermediate, and output types declared in
aggregation metadata match function implementation

core/trino-main/src/main/java/io/trino/operator/aggregation/InternalAggregationFunction.java

@@ -77,24 +77,28 @@ public String name()
         return name;
     }
 
+    @VisibleForTesting
     public List<Type> getParameterTypes()
     {
         return parameterTypes;
     }
 
+    @VisibleForTesting
     public Type getFinalType()
     {
         return finalType;
     }
 
-    public Type getIntermediateType()
+    @VisibleForTesting
+    public Optional<Type> getIntermediateType()
     {
-        if (intermediateType.size() == 1) {
-            return getOnlyElement(intermediateType);
+        if (intermediateType.isEmpty()) {
+            return Optional.empty();
         }
-        else {
-            return RowType.anonymous(intermediateType);
+        if (intermediateType.size() == 1) {
+            return Optional.of(getOnlyElement(intermediateType));
         }
+        return Optional.of(RowType.anonymous(intermediateType));
     }
 
     public List<Class<?>> getLambdaInterfaces()

core/trino-main/src/test/java/io/trino/operator/TestRealAverageAggregation.java

@@ -14,8 +14,8 @@
 package io.trino.operator;
 
 import com.google.common.collect.ImmutableList;
+import io.trino.metadata.ResolvedFunction;
 import io.trino.operator.aggregation.AbstractTestAggregationFunction;
-import io.trino.operator.aggregation.InternalAggregationFunction;
 import io.trino.spi.block.Block;
 import io.trino.spi.block.BlockBuilder;
 import io.trino.spi.type.Type;
@@ -26,7 +26,6 @@
 import java.util.List;
 
 import static io.trino.block.BlockAssertions.createBlockOfReals;
-import static io.trino.metadata.MetadataManager.createTestMetadataManager;
 import static io.trino.operator.aggregation.AggregationTestUtils.assertAggregation;
 import static io.trino.spi.type.RealType.REAL;
 import static io.trino.sql.analyzer.TypeSignatureProvider.fromTypes;
@@ -36,35 +35,40 @@
 public class TestRealAverageAggregation
         extends AbstractTestAggregationFunction
 {
-    private InternalAggregationFunction avgFunction;
+    private ResolvedFunction avgFunction;
 
     @BeforeClass
     public void setUp()
     {
-        avgFunction = createTestMetadataManager().getAggregateFunctionImplementation(
-                metadata.resolveFunction(QualifiedName.of("avg"), fromTypes(REAL)));
+        avgFunction = metadata.resolveFunction(QualifiedName.of("avg"), fromTypes(REAL));
     }
 
     @Test
     public void averageOfNullIsNull()
     {
-        assertAggregation(avgFunction,
+        assertAggregation(
+                metadata,
+                avgFunction,
                 null,
                 createBlockOfReals(null, null));
     }
 
     @Test
     public void averageOfSingleValueEqualsThatValue()
     {
-        assertAggregation(avgFunction,
+        assertAggregation(
+                metadata,
+                avgFunction,
                 1.23f,
                 createBlockOfReals(1.23f));
     }
 
     @Test
     public void averageOfTwoMaxFloatsEqualsMaxFloat()
     {
-        assertAggregation(avgFunction,
+        assertAggregation(
+                metadata,
+                avgFunction,
                 Float.MAX_VALUE,
                 createBlockOfReals(Float.MAX_VALUE, Float.MAX_VALUE));
     }

core/trino-main/src/test/java/io/trino/operator/aggregation/AbstractTestAggregationFunction.java

@@ -61,12 +61,11 @@ public final void destroyTestAggregationFunction()
 
     protected abstract Block[] getSequenceBlocks(int start, int length);
 
-    protected final InternalAggregationFunction getFunction()
+    protected final ResolvedFunction getFunction()
     {
-        ResolvedFunction resolvedFunction = metadata.resolveFunction(
+        return metadata.resolveFunction(
                 QualifiedName.of(getFunctionName()),
                 fromTypes(getFunctionParameterTypes()));
-        return metadata.getAggregateFunctionImplementation(resolvedFunction);
     }
 
     protected abstract String getFunctionName();
@@ -102,7 +101,7 @@ public void testMultiplePositions()
     public void testAllPositionsNull()
     {
         // if there are no parameters skip this test
-        List<Type> parameterTypes = getFunction().getParameterTypes();
+        List<Type> parameterTypes = getFunction().getSignature().getArgumentTypes();
         if (parameterTypes.isEmpty()) {
             return;
         }
@@ -118,7 +117,7 @@ public void testAllPositionsNull()
     public void testMixedNullAndNonNullPositions()
     {
         // if there are no parameters skip this test
-        List<Type> parameterTypes = getFunction().getParameterTypes();
+        List<Type> parameterTypes = getFunction().getSignature().getArgumentTypes();
         if (parameterTypes.isEmpty()) {
             return;
         }
@@ -154,7 +153,7 @@ public void testSlidingWindow()
         }
         Page inputPage = new Page(totalPositions, getSequenceBlocks(0, totalPositions));
 
-        InternalAggregationFunction function = getFunction();
+        InternalAggregationFunction function = metadata.getAggregateFunctionImplementation(getFunction());
         List<Integer> channels = Ints.asList(createArgs(function));
         AccumulatorFactory accumulatorFactory = function.bind(channels, Optional.empty());
         PagesIndex pagesIndex = new PagesIndex.TestingFactory(false).newPagesIndex(function.getParameterTypes(), totalPositions);
@@ -213,7 +212,7 @@ protected static Block[] createAlternatingNullsBlock(List<Type> types, Block...
 
     protected void testAggregation(Object expectedValue, Block... blocks)
     {
-        assertAggregation(getFunction(), expectedValue, blocks);
+        assertAggregation(metadata, getFunction(), expectedValue, blocks);
     }
 
     protected void assertInvalidAggregation(Runnable runnable)

core/trino-main/src/test/java/io/trino/operator/aggregation/AggregationTestUtils.java

@@ -15,12 +15,16 @@
 
 import com.google.common.primitives.Ints;
 import io.trino.block.BlockAssertions;
+import io.trino.metadata.AggregationFunctionMetadata;
+import io.trino.metadata.Metadata;
+import io.trino.metadata.ResolvedFunction;
 import io.trino.operator.GroupByIdBlock;
 import io.trino.spi.Page;
 import io.trino.spi.block.Block;
 import io.trino.spi.block.BlockBuilder;
 import io.trino.spi.block.RunLengthEncodedBlock;
 import io.trino.spi.type.BooleanType;
+import io.trino.spi.type.Type;
 import org.apache.commons.math3.util.Precision;
 
 import java.util.Collections;
@@ -39,16 +43,16 @@ public final class AggregationTestUtils
 {
     private AggregationTestUtils() {}
 
-    public static void assertAggregation(InternalAggregationFunction function, Object expectedValue, Block... blocks)
+    public static void assertAggregation(Metadata metadata, ResolvedFunction resolvedFunction, Object expectedValue, Block... blocks)
     {
-        assertAggregation(function, expectedValue, new Page(blocks));
+        assertAggregation(metadata, resolvedFunction, expectedValue, new Page(blocks));
     }
 
-    public static void assertAggregation(InternalAggregationFunction function, Object expectedValue, Page page)
+    public static void assertAggregation(Metadata metadata, ResolvedFunction resolvedFunction, Object expectedValue, Page page)
     {
         BiFunction<Object, Object, Boolean> equalAssertion = makeValidityAssertion(expectedValue);
 
-        assertAggregation(function, equalAssertion, null, page, expectedValue);
+        assertAggregation(metadata, resolvedFunction, equalAssertion, null, page, expectedValue);
     }
 
     public static BiFunction<Object, Object, Boolean> makeValidityAssertion(Object expectedValue)
@@ -62,8 +66,15 @@ public static BiFunction<Object, Object, Boolean> makeValidityAssertion(Object e
         return Objects::equals;
     }
 
-    public static void assertAggregation(InternalAggregationFunction function, BiFunction<Object, Object, Boolean> equalAssertion, String testDescription, Page page, Object expectedValue)
+    public static void assertAggregation(Metadata metadata, ResolvedFunction resolvedFunction, BiFunction<Object, Object, Boolean> equalAssertion, String testDescription, Page page, Object expectedValue)
     {
+        AggregationFunctionMetadata functionMetadata = metadata.getAggregationFunctionMetadata(resolvedFunction);
+        InternalAggregationFunction function = metadata.getAggregateFunctionImplementation(resolvedFunction);
+
+        assertEquals(function.getParameterTypes(), resolvedFunction.getSignature().getArgumentTypes());
+        assertEquals(function.getFinalType(), resolvedFunction.getSignature().getReturnType());
+        assertEquals(function.getIntermediateType().map(Type::getTypeSignature), functionMetadata.getIntermediateType());
+
         int positions = page.getPositionCount();
         for (int i = 1; i < page.getChannelCount(); i++) {
             assertEquals(positions, page.getBlock(i).getPositionCount(), "input blocks provided are not equal in position count");