TestCaseSupplier.java

/*
 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
 * or more contributor license agreements. Licensed under the Elastic License
 * 2.0; you may not use this file except in compliance with the Elastic License
 * 2.0.
 */

package org.elasticsearch.xpack.esql.expression.function;

import org.apache.lucene.document.InetAddressPoint;
import org.apache.lucene.util.BytesRef;
import org.elasticsearch.common.network.InetAddresses;
import org.elasticsearch.geo.GeometryTestUtils;
import org.elasticsearch.geo.ShapeTestUtils;
import org.elasticsearch.logging.LogManager;
import org.elasticsearch.logging.Logger;
import org.elasticsearch.test.ESTestCase;
import org.elasticsearch.xpack.esql.expression.function.scalar.convert.AbstractConvertFunction;
import org.elasticsearch.xpack.esql.type.EsqlDataTypes;
import org.elasticsearch.xpack.ql.expression.Expression;
import org.elasticsearch.xpack.ql.expression.Literal;
import org.elasticsearch.xpack.ql.tree.Source;
import org.elasticsearch.xpack.ql.type.DataType;
import org.elasticsearch.xpack.ql.type.DataTypes;
import org.elasticsearch.xpack.ql.util.NumericUtils;
import org.elasticsearch.xpack.versionfield.Version;
import org.hamcrest.Matcher;

import java.math.BigInteger;
import java.time.Duration;
import java.time.Instant;
import java.time.Period;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.DoubleFunction;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.LongFunction;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

import static org.elasticsearch.xpack.ql.util.SpatialCoordinateTypes.CARTESIAN;
import static org.elasticsearch.xpack.ql.util.SpatialCoordinateTypes.GEO;
import static org.hamcrest.Matchers.equalTo;

/**
 * This class exists to give a human-readable string representation of the test case.
 */
public record TestCaseSupplier(String name, List<DataType> types, Supplier<TestCase> supplier)
    implements
        Supplier<TestCaseSupplier.TestCase> {

    private static final Logger logger = LogManager.getLogger(TestCaseSupplier.class);
    /**
     * Build a test case without types.
     *
     * @deprecated Supply types
     */
    @Deprecated
    public TestCaseSupplier(String name, Supplier<TestCase> supplier) {
        this(name, null, supplier);
    }

    /**
     * Build a test case named after the types it takes.
     */
    public TestCaseSupplier(List<DataType> types, Supplier<TestCase> supplier) {
        this(nameFromTypes(types), types, supplier);
    }

    public static String nameFromTypes(List<DataType> types) {
        return types.stream().map(t -> "<" + t.typeName() + ">").collect(Collectors.joining(", "));
    }

    public static List<TestCaseSupplier> stringCases(
        BinaryOperator<Object> expected,
        BiFunction<DataType, DataType, String> evaluatorToString,
        List<String> warnings,
        DataType expectedType
    ) {
        List<TypedDataSupplier> lhsSuppliers = new ArrayList<>();
        List<TypedDataSupplier> rhsSuppliers = new ArrayList<>();
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        for (DataType type : AbstractConvertFunction.STRING_TYPES) {
            lhsSuppliers.addAll(stringCases(type));
            rhsSuppliers.addAll(stringCases(type));
            casesCrossProduct(
                expected,
                lhsSuppliers,
                rhsSuppliers,
                evaluatorToString,
                (lhs, rhs) -> warnings,
                suppliers,
                expectedType,
                true
            );
        }
        return suppliers;
    }

    @Override
    public TestCase get() {
        TestCase supplied = supplier.get();
        if (types != null) {
            for (int i = 0; i < types.size(); i++) {
                if (supplied.getData().get(i).type() != types.get(i)) {
                    throw new IllegalStateException(
                        name + ": supplier/data type mismatch " + supplied.getData().get(i).type() + "/" + types.get(i)
                    );
                }
            }
        }
        return supplied;
    }

    @Override
    public String toString() {
        return name;
    }

    /**
     * Generate positive test cases for unary functions that operate on an {@code numeric}
     * fields by casting them to {@link DataTypes#DOUBLE}s.
     */
    public static List<TestCaseSupplier> forUnaryCastingToDouble(
        String name,
        String argName,
        UnaryOperator<Double> expected,
        Double min,
        Double max,
        List<String> warnings
    ) {
        String read = "Attribute[channel=0]";
        String eval = name + "[" + argName + "=";
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        forUnaryInt(
            suppliers,
            eval + castToDoubleEvaluator(read, DataTypes.INTEGER) + "]",
            DataTypes.DOUBLE,
            i -> expected.apply(Double.valueOf(i)),
            min.intValue(),
            max.intValue(),
            warnings
        );
        forUnaryLong(
            suppliers,
            eval + castToDoubleEvaluator(read, DataTypes.LONG) + "]",
            DataTypes.DOUBLE,
            i -> expected.apply(Double.valueOf(i)),
            min.longValue(),
            max.longValue(),
            warnings
        );
        forUnaryUnsignedLong(
            suppliers,
            eval + castToDoubleEvaluator(read, DataTypes.UNSIGNED_LONG) + "]",
            DataTypes.DOUBLE,
            ul -> expected.apply(ul.doubleValue()),
            BigInteger.valueOf((int) Math.ceil(min)),
            BigInteger.valueOf((int) Math.floor(max)),
            warnings
        );
        forUnaryDouble(suppliers, eval + read + "]", DataTypes.DOUBLE, expected::apply, min, max, warnings);
        return suppliers;
    }

    /**
     * Generate positive test cases for binary functions that operate on an {@code numeric}
     * fields by casting them to {@link DataTypes#DOUBLE}s.
     */
    public static List<TestCaseSupplier> forBinaryCastingToDouble(
        String name,
        String lhsName,
        String rhsName,
        BinaryOperator<Double> expected,
        Double lhsMin,
        Double lhsMax,
        Double rhsMin,
        Double rhsMax,
        List<String> warnings
    ) {
        List<TypedDataSupplier> lhsSuppliers = castToDoubleSuppliersFromRange(lhsMin, lhsMax);
        List<TypedDataSupplier> rhsSuppliers = castToDoubleSuppliersFromRange(rhsMin, rhsMax);
        return forBinaryCastingToDouble(name, lhsName, rhsName, expected, lhsSuppliers, rhsSuppliers, warnings);
    }

    public static List<TestCaseSupplier> forBinaryCastingToDouble(
        String name,
        String lhsName,
        String rhsName,
        BinaryOperator<Double> expected,
        List<TypedDataSupplier> lhsSuppliers,
        List<TypedDataSupplier> rhsSuppliers,
        List<String> warnings
    ) {
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        casesCrossProduct(
            (l, r) -> expected.apply(((Number) l).doubleValue(), ((Number) r).doubleValue()),
            lhsSuppliers,
            rhsSuppliers,
            (lhsType, rhsType) -> name
                + "["
                + lhsName
                + "="
                + castToDoubleEvaluator("Attribute[channel=0]", lhsType)
                + ", "
                + rhsName
                + "="
                + castToDoubleEvaluator("Attribute[channel=1]", rhsType)
                + "]",
            (lhs, rhs) -> warnings,
            suppliers,
            DataTypes.DOUBLE,
            false
        );
        return suppliers;
    }

    public static void casesCrossProduct(
        BinaryOperator<Object> expected,
        List<TypedDataSupplier> lhsSuppliers,
        List<TypedDataSupplier> rhsSuppliers,
        BiFunction<DataType, DataType, String> evaluatorToString,
        BiFunction<TypedData, TypedData, List<String>> warnings,
        List<TestCaseSupplier> suppliers,
        DataType expectedType,
        boolean symmetric
    ) {
        for (TypedDataSupplier lhsSupplier : lhsSuppliers) {
            for (TypedDataSupplier rhsSupplier : rhsSuppliers) {
                suppliers.add(testCaseSupplier(lhsSupplier, rhsSupplier, evaluatorToString, expectedType, expected, warnings));
                if (symmetric) {
                    suppliers.add(testCaseSupplier(rhsSupplier, lhsSupplier, evaluatorToString, expectedType, expected, warnings));
                }
            }
        }
    }

    public static TestCaseSupplier testCaseSupplier(
        TypedDataSupplier lhsSupplier,
        TypedDataSupplier rhsSupplier,
        BiFunction<DataType, DataType, String> evaluatorToString,
        DataType expectedType,
        BinaryOperator<Object> expectedValue
    ) {
        return testCaseSupplier(lhsSupplier, rhsSupplier, evaluatorToString, expectedType, expectedValue, (lhs, rhs) -> List.of());
    }

    private static TestCaseSupplier testCaseSupplier(
        TypedDataSupplier lhsSupplier,
        TypedDataSupplier rhsSupplier,
        BiFunction<DataType, DataType, String> evaluatorToString,
        DataType expectedType,
        BinaryOperator<Object> expectedValue,
        BiFunction<TypedData, TypedData, List<String>> warnings
    ) {
        String caseName = lhsSupplier.name() + ", " + rhsSupplier.name();
        return new TestCaseSupplier(caseName, List.of(lhsSupplier.type(), rhsSupplier.type()), () -> {
            TypedData lhsTyped = lhsSupplier.get();
            TypedData rhsTyped = rhsSupplier.get();
            TestCase testCase = new TestCase(
                List.of(lhsTyped, rhsTyped),
                evaluatorToString.apply(lhsSupplier.type(), rhsSupplier.type()),
                expectedType,
                equalTo(expectedValue.apply(lhsTyped.getValue(), rhsTyped.getValue()))
            );
            for (String warning : warnings.apply(lhsTyped, rhsTyped)) {
                testCase = testCase.withWarning(warning);
            }
            return testCase;
        });
    }

    public static List<TypedDataSupplier> castToDoubleSuppliersFromRange(Double Min, Double Max) {
        List<TypedDataSupplier> suppliers = new ArrayList<>();
        suppliers.addAll(intCases(Min.intValue(), Max.intValue(), true));
        suppliers.addAll(longCases(Min.longValue(), Max.longValue(), true));
        suppliers.addAll(ulongCases(BigInteger.valueOf((long) Math.ceil(Min)), BigInteger.valueOf((long) Math.floor(Max)), true));
        suppliers.addAll(doubleCases(Min, Max, true));
        return suppliers;
    }

    public record NumericTypeTestConfig<T>(Number min, Number max, BiFunction<Number, Number, T> expected, String evaluatorName) {}

    public record NumericTypeTestConfigs<T>(
        NumericTypeTestConfig<T> intStuff,
        NumericTypeTestConfig<T> longStuff,
        NumericTypeTestConfig<T> doubleStuff
    ) {
        public NumericTypeTestConfig<T> get(DataType type) {
            if (type == DataTypes.INTEGER) {
                return intStuff;
            }
            if (type == DataTypes.LONG) {
                return longStuff;
            }
            if (type == DataTypes.DOUBLE) {
                return doubleStuff;
            }
            throw new IllegalArgumentException("bogus numeric type [" + type + "]");
        }
    }

    public static DataType widen(DataType lhs, DataType rhs) {
        if (lhs == rhs) {
            return lhs;
        }
        if (lhs == DataTypes.DOUBLE || rhs == DataTypes.DOUBLE) {
            return DataTypes.DOUBLE;
        }
        if (lhs == DataTypes.LONG || rhs == DataTypes.LONG) {
            return DataTypes.LONG;
        }
        throw new IllegalArgumentException("Invalid numeric widening lhs: [" + lhs + "] rhs: [" + rhs + "]");
    }

    public static List<TypedDataSupplier> getSuppliersForNumericType(DataType type, Number min, Number max, boolean includeZero) {
        if (type == DataTypes.INTEGER) {
            return intCases(NumericUtils.saturatingIntValue(min), NumericUtils.saturatingIntValue(max), includeZero);
        }
        if (type == DataTypes.LONG) {
            return longCases(min.longValue(), max.longValue(), includeZero);
        }
        if (type == DataTypes.UNSIGNED_LONG) {
            return ulongCases(
                min instanceof BigInteger ? (BigInteger) min : BigInteger.valueOf(Math.max(min.longValue(), 0L)),
                max instanceof BigInteger ? (BigInteger) max : BigInteger.valueOf(Math.max(max.longValue(), 0L)),
                includeZero
            );
        }
        if (type == DataTypes.DOUBLE) {
            return doubleCases(min.doubleValue(), max.doubleValue(), includeZero);
        }
        throw new IllegalArgumentException("bogus numeric type [" + type + "]");
    }

    public static List<TestCaseSupplier> forBinaryComparisonWithWidening(
        NumericTypeTestConfigs<Boolean> typeStuff,
        String lhsName,
        String rhsName,
        BiFunction<TypedData, TypedData, List<String>> warnings,
        boolean allowRhsZero
    ) {
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        List<DataType> numericTypes = List.of(DataTypes.INTEGER, DataTypes.LONG, DataTypes.DOUBLE);

        for (DataType lhsType : numericTypes) {
            for (DataType rhsType : numericTypes) {
                DataType expected = widen(lhsType, rhsType);
                NumericTypeTestConfig<Boolean> expectedTypeStuff = typeStuff.get(expected);
                BiFunction<DataType, DataType, String> evaluatorToString = (lhs, rhs) -> expectedTypeStuff.evaluatorName()
                    + "["
                    + lhsName
                    + "="
                    + getCastEvaluator("Attribute[channel=0]", lhs, expected)
                    + ", "
                    + rhsName
                    + "="
                    + getCastEvaluator("Attribute[channel=1]", rhs, expected)
                    + "]";
                casesCrossProduct(
                    (l, r) -> expectedTypeStuff.expected().apply((Number) l, (Number) r),
                    getSuppliersForNumericType(lhsType, expectedTypeStuff.min(), expectedTypeStuff.max(), allowRhsZero),
                    getSuppliersForNumericType(rhsType, expectedTypeStuff.min(), expectedTypeStuff.max(), allowRhsZero),
                    evaluatorToString,
                    warnings,
                    suppliers,
                    DataTypes.BOOLEAN,
                    true
                );
            }
        }
        return suppliers;
    }

    public static List<TestCaseSupplier> forBinaryWithWidening(
        NumericTypeTestConfigs<Number> typeStuff,
        String lhsName,
        String rhsName,
        BiFunction<TypedData, TypedData, List<String>> warnings,
        boolean allowRhsZero
    ) {
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        List<DataType> numericTypes = List.of(DataTypes.INTEGER, DataTypes.LONG, DataTypes.DOUBLE);

        for (DataType lhsType : numericTypes) {
            for (DataType rhsType : numericTypes) {
                DataType expected = widen(lhsType, rhsType);
                NumericTypeTestConfig<Number> expectedTypeStuff = typeStuff.get(expected);
                BiFunction<DataType, DataType, String> evaluatorToString = (lhs, rhs) -> expectedTypeStuff.evaluatorName()
                    + "["
                    + lhsName
                    + "="
                    + getCastEvaluator("Attribute[channel=0]", lhs, expected)
                    + ", "
                    + rhsName
                    + "="
                    + getCastEvaluator("Attribute[channel=1]", rhs, expected)
                    + "]";
                casesCrossProduct(
                    (l, r) -> expectedTypeStuff.expected().apply((Number) l, (Number) r),
                    getSuppliersForNumericType(lhsType, expectedTypeStuff.min(), expectedTypeStuff.max(), true),
                    getSuppliersForNumericType(rhsType, expectedTypeStuff.min(), expectedTypeStuff.max(), allowRhsZero),
                    evaluatorToString,
                    warnings,
                    suppliers,
                    expected,
                    false
                );
            }
        }

        return suppliers;
    }

    public static List<TestCaseSupplier> forBinaryNotCasting(
        String name,
        String lhsName,
        String rhsName,
        BinaryOperator<Object> expected,
        DataType expectedType,
        List<TypedDataSupplier> lhsSuppliers,
        List<TypedDataSupplier> rhsSuppliers,
        List<String> warnings,
        boolean symmetric
    ) {
        return forBinaryNotCasting(
            name,
            lhsName,
            rhsName,
            expected,
            expectedType,
            lhsSuppliers,
            rhsSuppliers,
            (lhs, rhs) -> warnings,
            symmetric
        );
    }

    public static List<TestCaseSupplier> forBinaryNotCasting(
        String name,
        String lhsName,
        String rhsName,
        BinaryOperator<Object> expected,
        DataType expectedType,
        List<TypedDataSupplier> lhsSuppliers,
        List<TypedDataSupplier> rhsSuppliers,
        BiFunction<TypedData, TypedData, List<String>> warnings,
        boolean symmetric
    ) {
        List<TestCaseSupplier> suppliers = new ArrayList<>();
        casesCrossProduct(
            expected,
            lhsSuppliers,
            rhsSuppliers,
            (lhsType, rhsType) -> name + "[" + lhsName + "=Attribute[channel=0], " + rhsName + "=Attribute[channel=1]]",
            warnings,
            suppliers,
            expectedType,
            symmetric
        );
        return suppliers;
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#INTEGER}.
     */
    public static void forUnaryInt(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        IntFunction<Object> expectedValue,
        int lowerBound,
        int upperBound,
        Function<Number, List<String>> expectedWarnings
    ) {
        unaryNumeric(
            suppliers,
            expectedEvaluatorToString,
            intCases(lowerBound, upperBound, true),
            expectedType,
            n -> expectedValue.apply(n.intValue()),
            n -> expectedWarnings.apply(n.intValue())
        );
    }

    public static void forUnaryInt(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        IntFunction<Object> expectedValue,
        int lowerBound,
        int upperBound,
        List<String> warnings
    ) {
        forUnaryInt(suppliers, expectedEvaluatorToString, expectedType, expectedValue, lowerBound, upperBound, unused -> warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#LONG}.
     */
    public static void forUnaryLong(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        LongFunction<Object> expectedValue,
        long lowerBound,
        long upperBound,
        Function<Number, List<String>> expectedWarnings
    ) {
        unaryNumeric(
            suppliers,
            expectedEvaluatorToString,
            longCases(lowerBound, upperBound, true),
            expectedType,
            n -> expectedValue.apply(n.longValue()),
            expectedWarnings
        );
    }

    public static void forUnaryLong(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        LongFunction<Object> expectedValue,
        long lowerBound,
        long upperBound,
        List<String> warnings
    ) {
        forUnaryLong(suppliers, expectedEvaluatorToString, expectedType, expectedValue, lowerBound, upperBound, unused -> warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#UNSIGNED_LONG}.
     */
    public static void forUnaryUnsignedLong(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BigInteger, Object> expectedValue,
        BigInteger lowerBound,
        BigInteger upperBound,
        Function<BigInteger, List<String>> expectedWarnings
    ) {
        unaryNumeric(
            suppliers,
            expectedEvaluatorToString,
            ulongCases(lowerBound, upperBound, true),
            expectedType,
            n -> expectedValue.apply((BigInteger) n),
            n -> expectedWarnings.apply((BigInteger) n)
        );
    }

    public static void forUnaryUnsignedLong(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BigInteger, Object> expectedValue,
        BigInteger lowerBound,
        BigInteger upperBound,
        List<String> warnings
    ) {
        forUnaryUnsignedLong(suppliers, expectedEvaluatorToString, expectedType, expectedValue, lowerBound, upperBound, unused -> warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#DOUBLE}.
     */
    public static void forUnaryDouble(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        DoubleFunction<Object> expectedValue,
        double lowerBound,
        double upperBound,
        List<String> warnings
    ) {
        forUnaryDouble(suppliers, expectedEvaluatorToString, expectedType, expectedValue, lowerBound, upperBound, unused -> warnings);
    }

    public static void forUnaryDouble(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        DoubleFunction<Object> expectedValue,
        double lowerBound,
        double upperBound,
        DoubleFunction<List<String>> expectedWarnings
    ) {
        unaryNumeric(
            suppliers,
            expectedEvaluatorToString,
            doubleCases(lowerBound, upperBound, true),
            expectedType,
            n -> expectedValue.apply(n.doubleValue()),
            n -> expectedWarnings.apply(n.doubleValue())
        );
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#BOOLEAN}.
     */
    public static void forUnaryBoolean(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<Boolean, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, booleanCases(), expectedType, v -> expectedValue.apply((Boolean) v), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#DATETIME}.
     */
    public static void forUnaryDatetime(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<Instant, Object> expectedValue,
        List<String> warnings
    ) {
        unaryNumeric(
            suppliers,
            expectedEvaluatorToString,
            dateCases(),
            expectedType,
            n -> expectedValue.apply(Instant.ofEpochMilli(n.longValue())),
            warnings
        );
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link EsqlDataTypes#GEO_POINT}.
     */
    public static void forUnaryGeoPoint(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, geoPointCases(), expectedType, n -> expectedValue.apply((BytesRef) n), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link EsqlDataTypes#CARTESIAN_POINT}.
     */
    public static void forUnaryCartesianPoint(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, cartesianPointCases(), expectedType, n -> expectedValue.apply((BytesRef) n), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link EsqlDataTypes#GEO_SHAPE}.
     */
    public static void forUnaryGeoShape(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, geoShapeCases(), expectedType, n -> expectedValue.apply((BytesRef) n), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link EsqlDataTypes#CARTESIAN_SHAPE}.
     */
    public static void forUnaryCartesianShape(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, cartesianShapeCases(), expectedType, n -> expectedValue.apply((BytesRef) n), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#IP}.
     */
    public static void forUnaryIp(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, ipCases(), expectedType, v -> expectedValue.apply((BytesRef) v), warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#KEYWORD} and {@link DataTypes#TEXT}.
     */
    public static void forUnaryStrings(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        Function<BytesRef, List<String>> expectedWarnings
    ) {
        for (DataType type : AbstractConvertFunction.STRING_TYPES) {
            unary(
                suppliers,
                expectedEvaluatorToString,
                stringCases(type),
                expectedType,
                v -> expectedValue.apply((BytesRef) v),
                v -> expectedWarnings.apply((BytesRef) v)
            );
        }
    }

    public static void forUnaryStrings(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<BytesRef, Object> expectedValue,
        List<String> warnings
    ) {
        forUnaryStrings(suppliers, expectedEvaluatorToString, expectedType, expectedValue, unused -> warnings);
    }

    /**
     * Generate positive test cases for a unary function operating on an {@link DataTypes#VERSION}.
     */
    public static void forUnaryVersion(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        DataType expectedType,
        Function<Version, Object> expectedValue,
        List<String> warnings
    ) {
        unary(
            suppliers,
            expectedEvaluatorToString,
            versionCases(""),
            expectedType,
            v -> expectedValue.apply(new Version((BytesRef) v)),
            warnings
        );
    }

    private static void unaryNumeric(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        List<TypedDataSupplier> valueSuppliers,
        DataType expectedOutputType,
        Function<Number, Object> expectedValue,
        Function<Number, List<String>> expectedWarnings
    ) {
        unary(
            suppliers,
            expectedEvaluatorToString,
            valueSuppliers,
            expectedOutputType,
            v -> expectedValue.apply((Number) v),
            v -> expectedWarnings.apply((Number) v)
        );
    }

    private static void unaryNumeric(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        List<TypedDataSupplier> valueSuppliers,
        DataType expectedOutputType,
        Function<Number, Object> expected,
        List<String> warnings
    ) {
        unaryNumeric(suppliers, expectedEvaluatorToString, valueSuppliers, expectedOutputType, expected, unused -> warnings);
    }

    public static void unary(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        List<TypedDataSupplier> valueSuppliers,
        DataType expectedOutputType,
        Function<Object, Object> expectedValue,
        Function<Object, List<String>> expectedWarnings
    ) {
        for (TypedDataSupplier supplier : valueSuppliers) {
            suppliers.add(new TestCaseSupplier(supplier.name(), List.of(supplier.type()), () -> {
                TypedData typed = supplier.get();
                Object value = typed.getValue();
                logger.info("Value is " + value + " of type " + value.getClass());
                logger.info("expectedValue is " + expectedValue.apply(value));
                TestCase testCase = new TestCase(
                    List.of(typed),
                    expectedEvaluatorToString,
                    expectedOutputType,
                    equalTo(expectedValue.apply(value))
                );
                for (String warning : expectedWarnings.apply(value)) {
                    testCase = testCase.withWarning(warning);
                }
                return testCase;
            }));
        }

    }

    public static void unary(
        List<TestCaseSupplier> suppliers,
        String expectedEvaluatorToString,
        List<TypedDataSupplier> valueSuppliers,
        DataType expectedOutputType,
        Function<Object, Object> expected,
        List<String> warnings
    ) {
        unary(suppliers, expectedEvaluatorToString, valueSuppliers, expectedOutputType, expected, unused -> warnings);
    }

    public static List<TypedDataSupplier> intCases(int min, int max, boolean includeZero) {
        List<TypedDataSupplier> cases = new ArrayList<>();
        if (0 <= max && 0 >= min && includeZero) {
            cases.add(new TypedDataSupplier("<0 int>", () -> 0, DataTypes.INTEGER));
        }

        int lower = Math.max(min, 1);
        int upper = Math.min(max, Integer.MAX_VALUE);
        if (lower < upper) {
            cases.add(new TypedDataSupplier("<positive int>", () -> ESTestCase.randomIntBetween(lower, upper), DataTypes.INTEGER));
        } else if (lower == upper) {
            cases.add(new TypedDataSupplier("<" + lower + " int>", () -> lower, DataTypes.INTEGER));
        }

        int lower1 = Math.max(min, Integer.MIN_VALUE);
        int upper1 = Math.min(max, -1);
        if (lower1 < upper1) {
            cases.add(new TypedDataSupplier("<negative int>", () -> ESTestCase.randomIntBetween(lower1, upper1), DataTypes.INTEGER));
        } else if (lower1 == upper1) {
            cases.add(new TypedDataSupplier("<" + lower1 + " int>", () -> lower1, DataTypes.INTEGER));
        }
        return cases;
    }

    public static List<TypedDataSupplier> longCases(long min, long max, boolean includeZero) {
        List<TypedDataSupplier> cases = new ArrayList<>();
        if (0L <= max && 0L >= min && includeZero) {
            cases.add(new TypedDataSupplier("<0 long>", () -> 0L, DataTypes.LONG));
        }

        long lower = Math.max(min, 1);
        long upper = Math.min(max, Long.MAX_VALUE);
        if (lower < upper) {
            cases.add(new TypedDataSupplier("<positive long>", () -> ESTestCase.randomLongBetween(lower, upper), DataTypes.LONG));
        } else if (lower == upper) {
            cases.add(new TypedDataSupplier("<" + lower + " long>", () -> lower, DataTypes.LONG));
        }

        long lower1 = Math.max(min, Long.MIN_VALUE);
        long upper1 = Math.min(max, -1);
        if (lower1 < upper1) {
            cases.add(new TypedDataSupplier("<negative long>", () -> ESTestCase.randomLongBetween(lower1, upper1), DataTypes.LONG));
        } else if (lower1 == upper1) {
            cases.add(new TypedDataSupplier("<" + lower1 + " long>", () -> lower1, DataTypes.LONG));
        }

        return cases;
    }

    public static List<TypedDataSupplier> ulongCases(BigInteger min, BigInteger max, boolean includeZero) {
        List<TypedDataSupplier> cases = new ArrayList<>();

        // Zero
        if (BigInteger.ZERO.compareTo(max) <= 0 && BigInteger.ZERO.compareTo(min) >= 0 && includeZero) {
            cases.add(new TypedDataSupplier("<0 unsigned long>", () -> BigInteger.ZERO, DataTypes.UNSIGNED_LONG));
        }

        // small values, less than Long.MAX_VALUE
        BigInteger lower1 = min.max(BigInteger.ONE);
        BigInteger upper1 = max.min(BigInteger.valueOf(Long.MAX_VALUE));
        if (lower1.compareTo(upper1) < 0) {
            cases.add(
                new TypedDataSupplier(
                    "<small unsigned long>",
                    () -> ESTestCase.randomUnsignedLongBetween(lower1, upper1),
                    DataTypes.UNSIGNED_LONG
                )
            );
        } else if (lower1.compareTo(upper1) == 0) {
            cases.add(new TypedDataSupplier("<small unsigned long>", () -> lower1, DataTypes.UNSIGNED_LONG));
        }

        // Big values, greater than Long.MAX_VALUE
        BigInteger lower2 = min.max(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.ONE));
        BigInteger upper2 = max.min(ESTestCase.UNSIGNED_LONG_MAX);
        if (lower2.compareTo(upper2) < 0) {
            cases.add(
                new TypedDataSupplier(
                    "<big unsigned long>",
                    () -> ESTestCase.randomUnsignedLongBetween(lower2, upper2),
                    DataTypes.UNSIGNED_LONG
                )
            );
        } else if (lower2.compareTo(upper2) == 0) {
            cases.add(new TypedDataSupplier("<big unsigned long>", () -> lower2, DataTypes.UNSIGNED_LONG));
        }
        return cases;
    }

    public static List<TypedDataSupplier> doubleCases(double min, double max, boolean includeZero) {
        List<TypedDataSupplier> cases = new ArrayList<>();

        // Zeros
        if (0d <= max && 0d >= min && includeZero) {
            cases.add(new TypedDataSupplier("<0 double>", () -> 0.0d, DataTypes.DOUBLE));
            cases.add(new TypedDataSupplier("<-0 double>", () -> -0.0d, DataTypes.DOUBLE));
        }

        // Positive small double
        double lower1 = Math.max(0d, min);
        double upper1 = Math.min(1d, max);
        if (lower1 < upper1) {
            cases.add(
                new TypedDataSupplier(
                    "<small positive double>",
                    () -> ESTestCase.randomDoubleBetween(lower1, upper1, true),
                    DataTypes.DOUBLE
                )
            );
        } else if (lower1 == upper1) {
            cases.add(new TypedDataSupplier("<small positive double>", () -> lower1, DataTypes.DOUBLE));
        }

        // Negative small double
        double lower2 = Math.max(-1d, min);
        double upper2 = Math.min(0d, max);
        if (lower2 < upper2) {
            cases.add(
                new TypedDataSupplier(
                    "<small negative double>",
                    () -> ESTestCase.randomDoubleBetween(lower2, upper2, true),
                    DataTypes.DOUBLE
                )
            );
        } else if (lower2 == upper2) {
            cases.add(new TypedDataSupplier("<small negative double>", () -> lower2, DataTypes.DOUBLE));
        }

        // Positive big double
        double lower3 = Math.max(1d, min); // start at 1 (inclusive) because the density of values between 0 and 1 is very high
        double upper3 = Math.min(Double.MAX_VALUE, max);
        if (lower3 < upper3) {
            cases.add(
                new TypedDataSupplier("<big positive double>", () -> ESTestCase.randomDoubleBetween(lower3, upper3, true), DataTypes.DOUBLE)
            );
        } else if (lower3 == upper3) {
            cases.add(new TypedDataSupplier("<big positive double>", () -> lower3, DataTypes.DOUBLE));
        }

        // Negative big double
        // note: Double.MIN_VALUE is the smallest non-zero positive double, not the smallest non-infinite negative double.
        double lower4 = Math.max(-Double.MAX_VALUE, min);
        double upper4 = Math.min(-1, max); // because again, the interval from -1 to 0 is very high density
        if (lower4 < upper4) {
            cases.add(
                new TypedDataSupplier("<big negative double>", () -> ESTestCase.randomDoubleBetween(lower4, upper4, true), DataTypes.DOUBLE)
            );
        } else if (lower4 == upper4) {
            cases.add(new TypedDataSupplier("<big negative double>", () -> lower4, DataTypes.DOUBLE));
        }
        return cases;
    }

    public static List<TypedDataSupplier> booleanCases() {
        return List.of(
            new TypedDataSupplier("<true>", () -> true, DataTypes.BOOLEAN),
            new TypedDataSupplier("<false>", () -> false, DataTypes.BOOLEAN)
        );
    }

    public static List<TypedDataSupplier> dateCases() {
        return List.of(
            new TypedDataSupplier("<1970-01-01T00:00:00Z>", () -> 0L, DataTypes.DATETIME),
            new TypedDataSupplier(
                "<date>",
                () -> ESTestCase.randomLongBetween(0, 10 * (long) 10e11), // 1970-01-01T00:00:00Z - 2286-11-20T17:46:40Z
                DataTypes.DATETIME
            ),
            new TypedDataSupplier(
                "<far future date>",
                // 2286-11-20T17:46:40Z - +292278994-08-17T07:12:55.807Z
                () -> ESTestCase.randomLongBetween(10 * (long) 10e11, Long.MAX_VALUE),
                DataTypes.DATETIME
            ),
            new TypedDataSupplier(
                "<near the end of time>",
                // very close to +292278994-08-17T07:12:55.807Z, the maximum supported millis since epoch
                () -> ESTestCase.randomLongBetween(Long.MAX_VALUE / 100 * 99, Long.MAX_VALUE),
                DataTypes.DATETIME
            )
        );
    }

    public static List<TypedDataSupplier> datePeriodCases() {
        return List.of(
            new TypedDataSupplier("<zero date period>", () -> Period.ZERO, EsqlDataTypes.DATE_PERIOD),
            new TypedDataSupplier(
                "<random date period>",
                () -> Period.of(
                    ESTestCase.randomIntBetween(-1000, 1000),
                    ESTestCase.randomIntBetween(-13, 13),
                    ESTestCase.randomIntBetween(-32, 32)
                ),
                EsqlDataTypes.DATE_PERIOD
            )
        );
    }

    public static List<TypedDataSupplier> timeDurationCases() {
        return List.of(
            new TypedDataSupplier("<zero time duration>", () -> Duration.ZERO, EsqlDataTypes.TIME_DURATION),
            new TypedDataSupplier(
                "<up to 7 days duration>",
                () -> Duration.ofMillis(ESTestCase.randomLongBetween(-604800000L, 604800000L)), // plus/minus 7 days
                EsqlDataTypes.TIME_DURATION
            )
        );
    }

    public static List<TypedDataSupplier> geoPointCases() {
        return geoPointCases(ESTestCase::randomBoolean);
    }

    public static List<TypedDataSupplier> cartesianPointCases() {
        return cartesianPointCases(ESTestCase::randomBoolean);
    }

    public static List<TypedDataSupplier> geoShapeCases() {
        return geoShapeCases(ESTestCase::randomBoolean);
    }

    public static List<TypedDataSupplier> cartesianShapeCases() {
        return cartesianShapeCases(ESTestCase::randomBoolean);
    }

    public static List<TypedDataSupplier> geoPointCases(Supplier<Boolean> hasAlt) {
        return List.of(
            new TypedDataSupplier("<geo_point>", () -> GEO.asWkb(GeometryTestUtils.randomPoint(hasAlt.get())), EsqlDataTypes.GEO_POINT)
        );
    }

    public static List<TypedDataSupplier> cartesianPointCases(Supplier<Boolean> hasAlt) {
        return List.of(
            new TypedDataSupplier(
                "<cartesian_point>",
                () -> CARTESIAN.asWkb(ShapeTestUtils.randomPoint(hasAlt.get())),
                EsqlDataTypes.CARTESIAN_POINT
            )
        );
    }

    public static List<TypedDataSupplier> geoShapeCases(Supplier<Boolean> hasAlt) {
        return List.of(
            new TypedDataSupplier(
                "<geo_shape>",
                () -> GEO.asWkb(GeometryTestUtils.randomGeometryWithoutCircle(0, hasAlt.get())),
                EsqlDataTypes.GEO_SHAPE
            )
        );
    }

    public static List<TypedDataSupplier> cartesianShapeCases(Supplier<Boolean> hasAlt) {
        return List.of(
            new TypedDataSupplier(
                "<cartesian_shape>",
                () -> CARTESIAN.asWkb(ShapeTestUtils.randomGeometry(hasAlt.get())),
                EsqlDataTypes.CARTESIAN_SHAPE
            )
        );
    }

    public static List<TypedDataSupplier> ipCases() {
        return List.of(
            new TypedDataSupplier(
                "<127.0.0.1 ip>",
                () -> new BytesRef(InetAddressPoint.encode(InetAddresses.forString("127.0.0.1"))),
                DataTypes.IP
            ),
            new TypedDataSupplier("<ipv4>", () -> new BytesRef(InetAddressPoint.encode(ESTestCase.randomIp(true))), DataTypes.IP),
            new TypedDataSupplier("<ipv6>", () -> new BytesRef(InetAddressPoint.encode(ESTestCase.randomIp(false))), DataTypes.IP)
        );
    }

    public static List<TypedDataSupplier> stringCases(DataType type) {
        List<TypedDataSupplier> result = new ArrayList<>();
        result.add(new TypedDataSupplier("<empty " + type + ">", () -> new BytesRef(""), type));
        result.add(
            new TypedDataSupplier("<short alpha " + type + ">", () -> new BytesRef(ESTestCase.randomAlphaOfLengthBetween(1, 30)), type)
        );
        result.add(
            new TypedDataSupplier("<long alpha " + type + ">", () -> new BytesRef(ESTestCase.randomAlphaOfLengthBetween(300, 3000)), type)
        );
        result.add(
            new TypedDataSupplier(
                "<short unicode " + type + ">",
                () -> new BytesRef(ESTestCase.randomRealisticUnicodeOfLengthBetween(1, 30)),
                type
            )
        );
        result.add(
            new TypedDataSupplier(
                "<long unicode " + type + ">",
                () -> new BytesRef(ESTestCase.randomRealisticUnicodeOfLengthBetween(300, 3000)),
                type
            )
        );
        return result;
    }

    /**
     * Supplier test case data for {@link Version} fields.
     */
    public static List<TypedDataSupplier> versionCases(String prefix) {
        return List.of(
            new TypedDataSupplier(
                "<" + prefix + "version major>",
                () -> new Version(Integer.toString(ESTestCase.between(0, 100))).toBytesRef(),
                DataTypes.VERSION
            ),
            new TypedDataSupplier(
                "<" + prefix + "version major.minor>",
                () -> new Version(ESTestCase.between(0, 100) + "." + ESTestCase.between(0, 100)).toBytesRef(),
                DataTypes.VERSION
            ),
            new TypedDataSupplier(
                "<" + prefix + "version major.minor.patch>",
                () -> new Version(ESTestCase.between(0, 100) + "." + ESTestCase.between(0, 100) + "." + ESTestCase.between(0, 100))
                    .toBytesRef(),
                DataTypes.VERSION
            )
        );
    }

    public static String getCastEvaluator(String original, DataType current, DataType target) {
        if (current == target) {
            return original;
        }
        if (target == DataTypes.LONG) {
            return castToLongEvaluator(original, current);
        }
        if (target == DataTypes.UNSIGNED_LONG) {
            return castToUnsignedLongEvaluator(original, current);
        }
        if (target == DataTypes.DOUBLE) {
            return castToDoubleEvaluator(original, current);
        }
        throw new IllegalArgumentException("Invalid numeric cast to [" + target + "]");
    }

    private static String castToLongEvaluator(String original, DataType current) {
        if (current == DataTypes.LONG) {
            return original;
        }
        if (current == DataTypes.INTEGER) {
            return "CastIntToLongEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.DOUBLE) {
            return "CastDoubleToLongEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.UNSIGNED_LONG) {
            return "CastUnsignedLongToLong[v=" + original + "]";
        }
        throw new UnsupportedOperationException();
    }

    private static String castToUnsignedLongEvaluator(String original, DataType current) {
        if (current == DataTypes.UNSIGNED_LONG) {
            return original;
        }
        if (current == DataTypes.INTEGER) {
            return "CastIntToUnsignedLongEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.LONG) {
            return "CastLongToUnsignedLongEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.DOUBLE) {
            return "CastDoubleToUnsignedLongEvaluator[v=" + original + "]";
        }
        throw new UnsupportedOperationException();
    }

    private static String castToDoubleEvaluator(String original, DataType current) {
        if (current == DataTypes.DOUBLE) {
            return original;
        }
        if (current == DataTypes.INTEGER) {
            return "CastIntToDoubleEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.LONG) {
            return "CastLongToDoubleEvaluator[v=" + original + "]";
        }
        if (current == DataTypes.UNSIGNED_LONG) {
            return "CastUnsignedLongToDoubleEvaluator[v=" + original + "]";
        }
        throw new UnsupportedOperationException();
    }

    public static class TestCase {
        /**
         * The {@link Source} this test case should be run with
         */
        private final Source source;
        /**
         * The parameter values and types to pass into the function for this test run
         */
        private final List<TypedData> data;

        /**
         * The expected toString output for the evaluator this function invocation should generate
         */
        private final Matcher<String> evaluatorToString;
        /**
         * The expected output type for the case being tested
         */
        private final DataType expectedType;
        /**
         * A matcher to validate the output of the function run on the given input data
         */
        private final Matcher<Object> matcher;

        /**
         * Warnings this test is expected to produce
         */
        private final String[] expectedWarnings;

        private final String expectedTypeError;
        private final boolean allTypesAreRepresentable;

        private final Class<? extends Throwable> foldingExceptionClass;
        private final String foldingExceptionMessage;

        public TestCase(List<TypedData> data, String evaluatorToString, DataType expectedType, Matcher<Object> matcher) {
            this(data, equalTo(evaluatorToString), expectedType, matcher);
        }

        public TestCase(List<TypedData> data, Matcher<String> evaluatorToString, DataType expectedType, Matcher<Object> matcher) {
            this(data, evaluatorToString, expectedType, matcher, null, null, null, null);
        }

        public static TestCase typeError(List<TypedData> data, String expectedTypeError) {
            return new TestCase(data, null, null, null, null, expectedTypeError, null, null);
        }

        TestCase(
            List<TypedData> data,
            Matcher<String> evaluatorToString,
            DataType expectedType,
            Matcher<Object> matcher,
            String[] expectedWarnings,
            String expectedTypeError,
            Class<? extends Throwable> foldingExceptionClass,
            String foldingExceptionMessage
        ) {
            this.source = Source.EMPTY;
            this.data = data;
            this.evaluatorToString = evaluatorToString;
            this.expectedType = expectedType;
            this.matcher = matcher;
            this.expectedWarnings = expectedWarnings;
            this.expectedTypeError = expectedTypeError;
            this.allTypesAreRepresentable = data.stream().allMatch(d -> EsqlDataTypes.isRepresentable(d.type));
            this.foldingExceptionClass = foldingExceptionClass;
            this.foldingExceptionMessage = foldingExceptionMessage;
        }

        public Source getSource() {
            return source;
        }

        public List<TypedData> getData() {
            return data;
        }

        public List<Expression> getDataAsFields() {
            return data.stream().map(TypedData::asField).collect(Collectors.toList());
        }

        public List<Expression> getDataAsDeepCopiedFields() {
            return data.stream().map(TypedData::asDeepCopyOfField).collect(Collectors.toList());
        }

        public List<Expression> getDataAsLiterals() {
            return data.stream().map(TypedData::asLiteral).collect(Collectors.toList());
        }

        public List<Object> getDataValues() {
            return data.stream().map(t -> t.data()).collect(Collectors.toList());
        }

        public boolean allTypesAreRepresentable() {
            return allTypesAreRepresentable;
        }

        public Matcher<Object> getMatcher() {
            return matcher;
        }

        public String[] getExpectedWarnings() {
            return expectedWarnings;
        }

        public Class<? extends Throwable> foldingExceptionClass() {
            return foldingExceptionClass;
        }

        public String foldingExceptionMessage() {
            return foldingExceptionMessage;
        }

        public String getExpectedTypeError() {
            return expectedTypeError;
        }

        public TestCase withWarning(String warning) {
            String[] newWarnings;
            if (expectedWarnings != null) {
                newWarnings = Arrays.copyOf(expectedWarnings, expectedWarnings.length + 1);
                newWarnings[expectedWarnings.length] = warning;
            } else {
                newWarnings = new String[] { warning };
            }
            return new TestCase(
                data,
                evaluatorToString,
                expectedType,
                matcher,
                newWarnings,
                expectedTypeError,
                foldingExceptionClass,
                foldingExceptionMessage
            );
        }

        public TestCase withFoldingException(Class<? extends Throwable> clazz, String message) {
            return new TestCase(data, evaluatorToString, expectedType, matcher, expectedWarnings, expectedTypeError, clazz, message);
        }

        public DataType expectedType() {
            return expectedType;
        }

        public Matcher<String> evaluatorToString() {
            return evaluatorToString;
        }
    }

    /**
     * Holds a supplier for a data value, along with the type of that value and a name for generating test case names. This mostly
     * exists because we can't generate random values from the test parameter generation functions, and instead need to return
     * suppliers which generate the random values at test execution time.
     */
    public record TypedDataSupplier(String name, Supplier<Object> supplier, DataType type, boolean forceLiteral) {

        public TypedDataSupplier(String name, Supplier<Object> supplier, DataType type) {
            this(name, supplier, type, false);
        }

        public TypedData get() {
            return new TypedData(supplier.get(), type, name, forceLiteral);
        }
    }

    /**
     * Holds a data value and the intended parse type of that value
     */
    public static class TypedData {
        public static final TypedData NULL = new TypedData(null, DataTypes.NULL, "<null>");

        private final Object data;
        private final DataType type;
        private final String name;
        private final boolean forceLiteral;

        /**
         * @param data value to test against
         * @param type type of the value, for building expressions
         * @param name a name for the value, used for generating test case names
         * @param forceLiteral should this data always be converted to a literal and <strong>never</strong> to a field reference?
         */
        private TypedData(Object data, DataType type, String name, boolean forceLiteral) {
            if (type == DataTypes.UNSIGNED_LONG && data instanceof BigInteger b) {
                this.data = NumericUtils.asLongUnsigned(b);
            } else {
                this.data = data;
            }
            this.type = type;
            this.name = name;
            this.forceLiteral = forceLiteral;
        }

        /**
         * @param data value to test against
         * @param type type of the value, for building expressions
         * @param name a name for the value, used for generating test case names
         */
        public TypedData(Object data, DataType type, String name) {
            this(data, type, name, false);
        }

        /**
         * Build a value, guessing the type via reflection.
         * @param data value to test against
         * @param name a name for the value, used for generating test case names
         */
        public TypedData(Object data, String name) {
            this(data, EsqlDataTypes.fromJava(data), name);
        }

        /**
         * Return a {@link TypedData} that always returns a {@link Literal} from
         * {@link #asField} and {@link #asDeepCopyOfField}. Use this for things that
         * must be constants.
         */
        public TypedData forceLiteral() {
            return new TypedData(data, type, name, true);
        }

        /**
         * Return a {@link TypedData} that always returns {@code null} for it's
         * value without modifying anything else in the supplier.
         */
        public TypedData forceValueToNull() {
            return new TypedData(null, type, name, forceLiteral);
        }

        @Override
        public String toString() {
            if (type == DataTypes.UNSIGNED_LONG && data instanceof Long longData) {
                return type.toString() + "(" + NumericUtils.unsignedLongAsBigInteger(longData).toString() + ")";
            }
            return type.toString() + "(" + (data == null ? "null" : data.toString()) + ")";
        }

        /**
         * Convert this into reference to a field.
         */
        public Expression asField() {
            if (forceLiteral) {
                return asLiteral();
            }
            return AbstractFunctionTestCase.field(name, type);
        }

        /**
         * Convert this into an anonymous function that performs a copy of the values loaded from a field.
         */
        public Expression asDeepCopyOfField() {
            if (forceLiteral) {
                return asLiteral();
            }
            return AbstractFunctionTestCase.deepCopyOfField(name, type);
        }

        /**
         * Convert this into a {@link Literal}.
         */
        public Literal asLiteral() {
            return new Literal(Source.synthetic(name), data, type);
        }

        /**
         * Value to test against.
         */
        public Object data() {
            return data;
        }

        /**
         * @return the data value being supplied, casting unsigned longs into BigIntegers correctly
         */
        public Object getValue() {
            if (type == DataTypes.UNSIGNED_LONG && data instanceof Long l) {
                return NumericUtils.unsignedLongAsBigInteger(l);
            }
            return data;
        }

        /**
         * Type of the value. For building {@link Expression}s.
         */
        public DataType type() {
            return type;
        }

        /**
         * A name for the value. Used to generate test names.
         */
        public String name() {
            return name;
        }
    }
}