test/ut/spec/data/dataValueHelper.test.ts

/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*/


import * as dataValueHelper from '@/src/data/helper/dataValueHelper';


const NO_SUCH_CASE = 'NO_SUCH_CASE';

// Tags for relational comparison cases.
// LT: less than, GT: greater than, INCMPR: incomparable
const TAG = {
    BothNumeric_AtLeastOneNumber_L_LT_R: 'BothNumeric_AtLeastOneNumber_L_LT_R',
    BothNumeric_AtLeastOneNumber_L_GT_R: 'BothNumeric_AtLeastOneNumber_L_GT_R',
    BothString_L_LT_R: 'BothString_L_LT_R',
    BothString_L_GT_R: 'BothString_L_GT_R',
    BothNumericString_NotStrictEQ_BeNumericEQ: 'BothNumericString_NotStrictEQ_BeNumericEQ',
    Strict_EQ: 'Strict_EQ',
    BothNumeric_OneNumber_NumericEQ: 'BothNumeric_OneNumber_NumericEQ',
    BothIncmpr_NotEQ: 'BothIncmpr_NotEQ',
    L_Incmpr_R_NumberOrString: 'L_Incmpr_R_NumberOrString',
    R_Incmpr_L_NumberOrString: 'R_Incmpr_L_NumberOrString'
} as const;

type CaseTag = typeof TAG[keyof typeof TAG];

type Operation = 'lt' | 'lte' | 'gt' | 'gte' | 'eq' | 'ne';
type Order = 'asc' | 'desc';
type Incomparable = 'min' | 'max';


const tagRevertPairs = [
    ['BothNumeric_AtLeastOneNumber_L_LT_R', 'BothNumeric_AtLeastOneNumber_L_GT_R'],
    ['BothString_L_LT_R', 'BothString_L_GT_R'],
    ['BothNumericString_NotStrictEQ_BeNumericEQ', 'BothNumericString_NotStrictEQ_BeNumericEQ'],
    ['Strict_EQ', 'Strict_EQ'],
    ['BothNumeric_OneNumber_NumericEQ', 'BothNumeric_OneNumber_NumericEQ'],
    ['BothIncmpr_NotEQ', 'BothIncmpr_NotEQ'],
    ['L_Incmpr_R_NumberOrString', 'R_Incmpr_L_NumberOrString']
] as const;

const filterResultMap = {
    BothNumeric_AtLeastOneNumber_L_LT_R: {
        lt: true,
        lte: true,
        gt: false,
        gte: false,
        eq: false,
        ne: true
    },
    BothNumeric_AtLeastOneNumber_L_GT_R: {
        lt: false,
        lte: false,
        gt: true,
        gte: true,
        eq: false,
        ne: true
    },
    BothString_L_LT_R: {
        lt: NO_SUCH_CASE,
        lte: NO_SUCH_CASE,
        gt: NO_SUCH_CASE,
        gte: NO_SUCH_CASE,
        eq: false,
        ne: true
    },
    BothString_L_GT_R: {
        lt: NO_SUCH_CASE,
        lte: NO_SUCH_CASE,
        gt: NO_SUCH_CASE,
        gte: NO_SUCH_CASE,
        eq: false,
        ne: true
    },
    BothNumericString_NotStrictEQ_BeNumericEQ: {
        lt: NO_SUCH_CASE,
        lte: NO_SUCH_CASE,
        gt: NO_SUCH_CASE,
        gte: NO_SUCH_CASE,
        eq: false,
        ne: true
    },
    Strict_EQ: {
        lt: false,
        lte: true,
        gt: false,
        gte: true,
        eq: true,
        ne: false
    },
    BothNumeric_OneNumber_NumericEQ: {
        lt: false,
        lte: true,
        gt: false,
        gte: true,
        eq: true,
        ne: false
    },
    BothIncmpr_NotEQ: {
        lt: false,
        lte: false,
        gt: false,
        gte: false,
        eq: false,
        ne: true
    },
    L_Incmpr_R_NumberOrString: {
        lt: false,
        lte: false,
        gt: false,
        gte: false,
        eq: false,
        ne: true
    },
    R_Incmpr_L_NumberOrString: {
        lt: false,
        lte: false,
        gt: false,
        gte: false,
        eq: false,
        ne: true
    }
} as const;

const sortResultMap = {
    BothNumeric_AtLeastOneNumber_L_LT_R: {
        asc_incmprmin: -1,
        asc_incmprmax: -1,
        desc_incmprmin: 1,
        desc_incmprmax: 1
    },
    BothNumeric_AtLeastOneNumber_L_GT_R: {
        asc_incmprmin: 1,
        asc_incmprmax: 1,
        desc_incmprmin: -1,
        desc_incmprmax: -1
    },
    BothString_L_LT_R: {
        asc_incmprmin: -1,
        asc_incmprmax: -1,
        desc_incmprmin: 1,
        desc_incmprmax: 1
    },
    BothString_L_GT_R: {
        asc_incmprmin: 1,
        asc_incmprmax: 1,
        desc_incmprmin: -1,
        desc_incmprmax: -1
    },
    BothNumericString_NotStrictEQ_BeNumericEQ: {
        asc_incmprmin: 0,
        asc_incmprmax: 0,
        desc_incmprmin: 0,
        desc_incmprmax: 0
    },
    Strict_EQ: {
        asc_incmprmin: 0,
        asc_incmprmax: 0,
        desc_incmprmin: 0,
        desc_incmprmax: 0
    },
    BothNumeric_OneNumber_NumericEQ: {
        asc_incmprmin: 0,
        asc_incmprmax: 0,
        desc_incmprmin: 0,
        desc_incmprmax: 0
    },
    BothIncmpr_NotEQ: {
        asc_incmprmin: 0,
        asc_incmprmax: 0,
        desc_incmprmin: 0,
        desc_incmprmax: 0
    },
    L_Incmpr_R_NumberOrString: {
        asc_incmprmin: -1,
        asc_incmprmax: 1,
        desc_incmprmin: 1,
        desc_incmprmax: -1
    },
    R_Incmpr_L_NumberOrString: {
        asc_incmprmin: 1,
        asc_incmprmax: -1,
        desc_incmprmin: -1,
        desc_incmprmax: 1
    }
} as const;

type EvaluateFunction = (lval: unknown, rval: unknown, caseTag: CaseTag) => void;

function eachRelationalComparisonCase(evalFn: EvaluateFunction) {

    const FULL_WIDTH_SPACE = String.fromCharCode(12288);

    const testerMap = {
        notEqualAndHasOrder: function () {
            expectDual(123, 555, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual(-123, -555, TAG.BothNumeric_AtLeastOneNumber_L_GT_R);
            expectDual(-123, 123, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);

            expectDual(Infinity, 123, TAG.BothNumeric_AtLeastOneNumber_L_GT_R);
            expectDual(-Infinity, -123, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual('Infinity', 123, TAG.BothNumeric_AtLeastOneNumber_L_GT_R);
            expectDual('-Infinity', 123, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual(123, '555', TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual(555, '555.6', TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual('-555', -555.6, TAG.BothNumeric_AtLeastOneNumber_L_GT_R);
            expectDual(123, ' 555 ', TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual(' -555 ', 123, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
            expectDual(123, ' \r \n 555 \t ' + FULL_WIDTH_SPACE, TAG.BothNumeric_AtLeastOneNumber_L_LT_R);
        },

        notEqualAndNoOrder: function () {
            const makeDate = () => new Date(2012, 5, 12);
            const makeFn = () => function () {};

            expectDual(NaN, NaN, TAG.BothIncmpr_NotEQ);
            expectDual(NaN, -NaN, TAG.BothIncmpr_NotEQ);
            expectDual(NaN, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(NaN, 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual('NaN', NaN, TAG.R_Incmpr_L_NumberOrString);
            expectDual('NaN', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('NaN', 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual('-NaN', -NaN, TAG.R_Incmpr_L_NumberOrString);
            expectDual('-NaN', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('-NaN', 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual(true, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(false, 1, TAG.L_Incmpr_R_NumberOrString);
            expectDual('true', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('false', 1, TAG.L_Incmpr_R_NumberOrString);
            expectDual(undefined, 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual(undefined, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(null, 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual(null, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(makeDate(), 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(makeDate(), makeDate(), TAG.BothIncmpr_NotEQ);
            expectDual(makeDate(), +makeDate(), TAG.L_Incmpr_R_NumberOrString);
            expectDual([], 1, TAG.L_Incmpr_R_NumberOrString);
            expectDual([], 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, 1, TAG.L_Incmpr_R_NumberOrString);
            expectDual([], '0', TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, '1', TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, '1', TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, '0', TAG.L_Incmpr_R_NumberOrString);
            expectDual(/1/, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(/0/, 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('555a', 123, TAG.L_Incmpr_R_NumberOrString);
            expectDual('abc', 123, TAG.L_Incmpr_R_NumberOrString);
            expectDual('abc', null, TAG.R_Incmpr_L_NumberOrString); // See [SORT_COMPARISON_RULE]
            expectDual('abc', '123', TAG.L_Incmpr_R_NumberOrString);
            expectDual('abc', 'abcde', TAG.BothString_L_LT_R);
            expectDual('abc', 'abc', TAG.Strict_EQ);
            expectDual('2', '12', TAG.BothString_L_LT_R); // '2' > '12' in JS but should not happen here.
            expectDual(' ', '', TAG.BothString_L_GT_R);
            expectDual(0.5, '0. 5', TAG.R_Incmpr_L_NumberOrString);
            expectDual('0.5', '0. 5', TAG.R_Incmpr_L_NumberOrString);
            expectDual('- 5', -5, TAG.L_Incmpr_R_NumberOrString);
            expectDual('-123.5', ' -123.5 ', TAG.BothNumericString_NotStrictEQ_BeNumericEQ);
            expectDual('0x11', 17, TAG.L_Incmpr_R_NumberOrString); // not 17 in int16.
            expectDual('0x11', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('0x0', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('0. 5', 0.5, TAG.L_Incmpr_R_NumberOrString);
            expectDual('0 .5', 0.5, TAG.L_Incmpr_R_NumberOrString);
            expectDual('', 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual('', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(' ', 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual(' ', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(' \n', '\n', TAG.BothString_L_GT_R);
            expectDual('\n', 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual('\n', 2, TAG.L_Incmpr_R_NumberOrString);
            expectDual({}, {}, TAG.BothIncmpr_NotEQ);
            expectDual({}, [], TAG.BothIncmpr_NotEQ);
            expectDual(makeFn(), makeFn(), TAG.BothIncmpr_NotEQ);
            expectDual(makeFn(), 0, TAG.L_Incmpr_R_NumberOrString);
            expectDual(makeFn(), 1, TAG.L_Incmpr_R_NumberOrString);
            expectDual(makeFn(), makeFn().toString(), TAG.L_Incmpr_R_NumberOrString);
        },

        equalNumeric: function () {
            expectDual(123, 123, TAG.Strict_EQ);
            expectDual(1e3, 1000, TAG.Strict_EQ);
            expectDual(-1e3, -1000, TAG.Strict_EQ);
            expectDual('1e3', 1000, TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual('-1e3', -1000, TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual(123, '123', TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual(123, ' 123 ', TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual(123.5, ' \n \r 123.5 \t ', TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual(123.5, 123.5 + FULL_WIDTH_SPACE, TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual(' -123.5 ', -123.5, TAG.BothNumeric_OneNumber_NumericEQ);
            expectDual('011', 11, TAG.BothNumeric_OneNumber_NumericEQ); // not 9 in int8.
        },

        equalOtherTypes: function () {
            const emptyObj = {};
            const emptyArr = [] as unknown[];
            const date = new Date(2012, 5, 12);
            const fn = function () {};
            expectDual(emptyObj, emptyObj, TAG.Strict_EQ);
            expectDual(emptyArr, emptyArr, TAG.Strict_EQ);
            expectDual(date, date, TAG.Strict_EQ);
            expectDual(fn, fn, TAG.Strict_EQ);
        }
    };

    function expectDual(lval: unknown, rval: unknown, caseTag: CaseTag) {
        validateCaseTag(caseTag);
        evalFn(lval, rval, caseTag);

        const revertedCaseTag = findRevertTag(caseTag);
        validateCaseTag(revertedCaseTag);
        evalFn(rval, lval, revertedCaseTag);
    }

    function validateCaseTag(caseTag: CaseTag) {
        expect(TAG.hasOwnProperty(caseTag)).toEqual(true);
    }

    function findRevertTag(caseTag: CaseTag) {
        for (let i = 0; i < tagRevertPairs.length; i++) {
            const item = tagRevertPairs[i];
            if (item[0] === caseTag) {
                return item[1];
            }
            else if (item[1] === caseTag) {
                return item[0];
            }
        }
    }

    Object.keys(testerMap).forEach((name: keyof typeof testerMap) => testerMap[name]());
}


describe('data/helper/dataValueHelper', function () {

    describe('filter_relational_comparison', function () {

        function testFilterComparator(op: Operation) {
            it(op + '_filter_comparator', () => {
                eachRelationalComparisonCase((lval, rval, caseTag) => {
                    expect(filterResultMap.hasOwnProperty(caseTag));
                    expect(filterResultMap[caseTag].hasOwnProperty(op));
                    const expectedResult = filterResultMap[caseTag][op];

                    if ((op === 'lt' || op === 'lte' || op === 'gt' || op === 'gte')
                        && typeof rval !== 'number'
                    ) {
                        expect(() => {
                            dataValueHelper.createFilterComparator(op, rval);
                        }).toThrow();
                    }
                    else {
                        const comparator = dataValueHelper.createFilterComparator(op, rval);
                        expect(comparator.evaluate(lval)).toEqual(expectedResult);
                    }
                });
            });
        }
        testFilterComparator('lt');
        testFilterComparator('lte');
        testFilterComparator('gt');
        testFilterComparator('gte');
        testFilterComparator('eq');
        testFilterComparator('ne');
    });

    describe('sort_relational_comparison', function () {

        function testSortComparator(order: Order, incomparable: Incomparable) {
            const key = order + '_incmpr' + incomparable;
            const SortOrderComparator = dataValueHelper.SortOrderComparator;
            const sortOrderComparator = new SortOrderComparator(order, incomparable);
            it(key + '_sort_comparator', () => {
                eachRelationalComparisonCase((lval, rval, caseTag) => {
                    expect(sortResultMap.hasOwnProperty(caseTag));
                    expect(sortResultMap[caseTag].hasOwnProperty(key));
                    const expectedResult = (sortResultMap[caseTag] as any)[key];
                    expect(sortOrderComparator.evaluate(lval, rval)).toEqual(expectedResult);
                });
            });
        }
        testSortComparator('asc', 'min');
        testSortComparator('asc', 'max');
        testSortComparator('desc', 'min');
        testSortComparator('desc', 'max');
    });

});