Skip to content

Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.

23.3 KB
Raw Blame
/**
 * Copyright 2023-present DreamNum Co., Ltd.
 *
 * Licensed 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 type { Nullable } from '@univerjs/core';
import type { BaseValueObject } from '../base-value-object';
import { DateSystem, Injector } from '@univerjs/core';
import { describe, expect, it } from 'vitest';
import { ErrorType } from '../../../basics/error-type';
import { compareToken } from '../../../basics/token';
import { getObjectValue } from '../../../functions/util';
import { FormulaCacheService } from '../../../services/formula-cache.service';
import { ArrayValueObject, transformToValueObject, ValueObjectFactory } from '../array-value-object';
import { ErrorValueObject } from '../base-value-object';
import { BooleanValueObject, NumberValueObject, StringValueObject } from '../primitive-object';

describe('arrayValueObject test', () => {
    it('matches uncached comparisons after repeated formula-result updates', () => {
        const values = [[1], [3], [5], [7], [9]];
        const injector = new Injector([[FormulaCacheService]]);
        const context = injector.get(FormulaCacheService).createCalculation()!;
        const createArray = (useInvertedIndexCache: boolean): ArrayValueObject => ArrayValueObject.create({
            calculateValueList: transformToValueObject(values),
            rowCount: values.length,
            columnCount: 1,
            unitId: 'updated-formulas',
            sheetId: 'sheet',
            row: 10,
            column: 2,
            useInvertedIndexCache,
        }).withCalculationCache(context);
        try {
            expect(createArray(true).usesInvertedIndexCache()).toBe(true);
            createArray(true).compare(NumberValueObject.create(3), compareToken.EQUALS);
            for (let update = 0; update < 100; update++) {
                const row = update % values.length;
                values[row][0] = (update * 7) % 11;
                context.invertedIndex.set('updated-formulas', 'sheet', 2, values[row][0], row + 10, true);
                for (const operator of Object.values(compareToken)) {
                    const criterion = NumberValueObject.create(update % 11);
                    const cached = createArray(true).compare(criterion, operator);
                    const uncached = createArray(false).compare(criterion, operator);
                    for (let index = 0; index < values.length; index++) {
                        expect(cached.getValueOrDefault(index, 0)!.getValue()).toEqual(uncached.getValueOrDefault(index, 0)!.getValue());
                    }
                }
            }
        } finally {
            injector.dispose();
        }
    });

    const originArrayValueObject = ArrayValueObject.create({
        calculateValueList: transformToValueObject([
            [1, 2, 3, 4, 5],
            [6, 7, 8, 9, 10],
            [11, 12, 13, 14, 15],
        ]),
        rowCount: 3,
        columnCount: 5,
        unitId: '',
        sheetId: '',
        row: 0,
        column: 0,
    });

    it('binds child values when the array already uses the requested date system', () => {
        const array = ArrayValueObject.create({
            calculateValueList: [[StringValueObject.create('1904-1-1')]],
            rowCount: 1,
            columnCount: 1,
            unitId: '',
            sheetId: '',
            row: 0,
            column: 0,
        }, DateSystem.Date1904);

        const value = array.withDateSystem(DateSystem.Date1904).get(0, 0) as BaseValueObject;

        expect(value.convertToNumberObjectValue().getValue()).toBe(0);
    });

    it('binds the date system in place and updates child values', () => {
        const array = ArrayValueObject.create({
            calculateValueList: [[StringValueObject.create('1904-1-1')]],
            rowCount: 1,
            columnCount: 1,
            unitId: '',
            sheetId: '',
            row: 0,
            column: 0,
        });

        expect(array.withDateSystem(DateSystem.Date1904)).toBe(array);
        expect(array.getDateSystem()).toBe(DateSystem.Date1904);
        expect(array.get(0, 0)?.getDateSystem()).toBe(DateSystem.Date1904);
    });

    it('maps sparse comparison arrays with their default value', () => {
        const sparseValues: BaseValueObject[][] = [];
        sparseValues[1] = [BooleanValueObject.create(true)];

        const sparseArray = ArrayValueObject.create({
            calculateValueList: sparseValues,
            rowCount: 3,
            columnCount: 1,
            unitId: '',
            sheetId: '',
            row: -1,
            column: -1,
        });
        sparseArray.setDefaultValue(BooleanValueObject.create(false));

        const result = sparseArray.getNegative().getNegative();

        expect(getObjectValue(result)).toStrictEqual([
            [0],
            [1],
            [0],
        ]);
    });

    describe('slice', () => {
        it('row==null;column=2,,', () => {
            const result = originArrayValueObject.slice(null, [2])!;

            expect(getObjectValue(result)).toStrictEqual([
                [3, 4, 5],
                [8, 9, 10],
                [13, 14, 15],
            ]);
        });

        it('row==2,,;column=2,,', () => {
            const result = originArrayValueObject.slice([2], [2])!;

            expect(getObjectValue(result)).toStrictEqual([
                [13, 14, 15],
            ]);
        });

        it('row==,,2;column=2,,', () => {
            const result = originArrayValueObject.slice([undefined, undefined, 2], [2])!;

            expect(getObjectValue(result)).toStrictEqual([
                [3, 4, 5],
                [13, 14, 15],
            ]);
        });

        it('row==1,,;column=null', () => {
            const result = originArrayValueObject.slice([1])!;

            expect(getObjectValue(result)).toStrictEqual([
                [6, 7, 8, 9, 10],
                [11, 12, 13, 14, 15],
            ]);
        });

        it('row==0,1,;column=,,2', () => {
            const result = originArrayValueObject.slice([0, 1], [undefined, undefined, 2])!;

            expect(getObjectValue(result)).toStrictEqual([
                [1, 3, 5],
            ]);
        });

        it('row==0,1,;column=,,2,first undefined', () => {
            const result = originArrayValueObject.slice(undefined, [2, 3])!;

            expect(getObjectValue(result)).toStrictEqual([
                [3],
                [8],
                [13],
            ]);
        });

        it('row==1,3,;column=1,4,', () => {
            const result = originArrayValueObject.slice([1, 3], [1, 4])!;

            expect(getObjectValue(result)).toStrictEqual([
                [7, 8, 9],
                [12, 13, 14],
            ]);
        });

        it('row==3,,;column=,,', () => {
            const result = originArrayValueObject.slice([3]);

            expect(result).toBeUndefined();
        });

        it('row==,,;column=5,,', () => {
            const result = originArrayValueObject.slice(undefined, [5]);

            expect(result).toBeUndefined();
        });
    });

    describe('Count', () => {
        it('Normal count', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.count();

            expect(getObjectValue(result)).toBe(6);
        });
        it('Counta', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.countA();

            expect(getObjectValue(result)).toBe(10);
        });
        it('CountBlank', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false, '', null],
                    [0, '100', '2.34', 'test', -3, ErrorType.VALUE, null],
                ]),
                rowCount: 2,
                columnCount: 7,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.countBlank();

            expect(getObjectValue(result)).toBe(3);
        });
    });

    describe('pick', () => {
        it('normal', () => {
            const pickArrayValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [true, false, false, true, false],
                    [true, false, true, false, false],
                    [true, false, true, false, false],
                ]),
                rowCount: 3,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originArrayValueObject.pick(pickArrayValueObject);

            expect(getObjectValue(result)).toStrictEqual([
                [1, 4, 6, 8, 11, 13],
            ]);
        });

        it('not boolean', () => {
            const pickArrayValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [true, false, false, 1, false],
                    [true, false, 1, false, false],
                    [true, false, 1, false, false],
                ]),
                rowCount: 3,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originArrayValueObject.pick(pickArrayValueObject);

            expect(getObjectValue(result)).toStrictEqual([
                [1, 6, 11],
            ]);
        });

        it('pick and sum', () => {
            const pickArrayValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [true, false, false, true, false],
                    [true, false, true, false, false],
                    [true, false, true, false, false],
                ]),
                rowCount: 3,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originArrayValueObject.pick(pickArrayValueObject).sum();

            expect(getObjectValue(result)).toStrictEqual(43);
        });
    });

    describe('sum', () => {
        it('normal', () => {
            const result = originArrayValueObject.sum();

            expect(getObjectValue(result)).toStrictEqual(120);
        });

        it('nm multiple formats', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.sum();

            expect(getObjectValue(result) as number).toBeCloseTo(101.57);
        });
    });

    describe('mean', () => {
        it('normal', () => {
            const result = originArrayValueObject.mean();

            expect(getObjectValue(result)).toStrictEqual(8);
        });

        it('nm multiple formats', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.mean();

            expect(getObjectValue(result, true)).toStrictEqual(16.9283333333);
        });
    });

    describe('var', () => {
        it('normal', () => {
            const result = originArrayValueObject.var();

            expect(getObjectValue(result, true)).toStrictEqual(18.6666666667);
        });

        it('var nm multiple formats', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.var();

            expect(getObjectValue(result, true)).toStrictEqual(1382.92961388889);
        });
    });

    describe('std', () => {
        it('normal', () => {
            const result = originArrayValueObject.std();

            expect(getObjectValue(result, true)).toStrictEqual(4.32049379894);
        });

        it('nm multiple formats', () => {
            const originValueObject = ArrayValueObject.create({
                calculateValueList: transformToValueObject([
                    [1, ' ', 1.23, true, false],
                    [0, '100', '2.34', 'test', -3],
                ]),
                rowCount: 2,
                columnCount: 5,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });
            const result = originValueObject.std();

            expect(getObjectValue(result, true)).toStrictEqual(37.1877616144);
        });
    });

    describe('getNegative', () => {
        it('normal', () => {
            const result = originArrayValueObject.getNegative();

            expect(getObjectValue(result)).toStrictEqual([
                [-1, -2, -3, -4, -5],
                [-6, -7, -8, -9, -10],
                [-11, -12, -13, -14, -15],
            ]);
        });
    });

    describe('ValueObjectFactory', () => {
        it.each([
            ['12.50', 12.5],
            ['1.', 1],
            ['+.5', 0.5],
            ['007', 7],
            ['1.5e-2', 0.015],
        ])('parses decimal formula number literals: %s', (token, expected) => {
            const value = ValueObjectFactory.createNumberLiteral(token, DateSystem.Date1904);

            expect(value?.isNumber()).toBe(true);
            expect(value?.getValue()).toBe(expected);
            expect(value?.getDateSystem()).toBe(DateSystem.Date1904);
        });

        it.each(['', '0x10', '0b11', 'Infinity', '1e+', '1.2.3', '"12.50"'])(
            'rejects tokens outside decimal formula number syntax: %s',
            (token) => {
                expect(ValueObjectFactory.createNumberLiteral(token)).toBeNull();
            }
        );

        it('rejects long malformed number literals', () => {
            const token = `${'1'.repeat(32_000)}x`;

            expect(ValueObjectFactory.createNumberLiteral(token)).toBeNull();
        });

        it.each(['000123456', '123456789123456789'])(
            'preserves numeric cell text when formula literals are parsed separately: %s',
            (token) => {
                const value = ValueObjectFactory.create(token, true);

                expect(value.isString()).toBe(true);
                expect(value.getValue()).toBe(token);
            }
        );

        it('ValueObjectFactory create BooleanValueObject ', () => {
            let booleanValueObject = ValueObjectFactory.create(true);

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();

            booleanValueObject = ValueObjectFactory.create(false);

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();

            booleanValueObject = ValueObjectFactory.create('true');

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();

            booleanValueObject = ValueObjectFactory.create('false');

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();
            booleanValueObject = ValueObjectFactory.create('TRUE');

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();

            booleanValueObject = ValueObjectFactory.create('FALSE');

            expect((booleanValueObject as BooleanValueObject).isBoolean()).toBeTruthy();
        });
        it('ValueObjectFactory create NumberValueObject ', () => {
            let numberValueObject = ValueObjectFactory.create(1);

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();

            numberValueObject = ValueObjectFactory.create(0);

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();
            numberValueObject = ValueObjectFactory.create(-1);

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();

            numberValueObject = ValueObjectFactory.create('1');

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();

            numberValueObject = ValueObjectFactory.create(1e2);

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();

            numberValueObject = ValueObjectFactory.create('1e2');

            expect((numberValueObject as NumberValueObject).isNumber()).toBeTruthy();
        });

        it('ValueObjectFactory create ArrayValueObject ', () => {
            let arrayValueObject = ValueObjectFactory.create('{1,2,3;4,5,6}');

            expect((arrayValueObject as ArrayValueObject).isArray()).toBeTruthy();

            arrayValueObject = ValueObjectFactory.create('{1,2,3;4,5,6}');

            expect((arrayValueObject as ArrayValueObject).isArray()).toBeTruthy();

            arrayValueObject = ValueObjectFactory.create(`{
                1 , 2;
                4 , 5
            }`);

            expect((arrayValueObject as ArrayValueObject).toValue()).toStrictEqual([
                [1, 2],
                [4, 5],
            ]);
        });

        it('ValueObjectFactory create StringValueObject ', () => {
            let stringValueObject = ValueObjectFactory.create('test');

            expect(stringValueObject.isString()).toBeTruthy();

            stringValueObject = ValueObjectFactory.create(' ');

            expect(stringValueObject.isString()).toBeTruthy();
        });

        it('Array constants preserve quoted numeric and date text', () => {
            const arrayValueObject = ValueObjectFactory.create('{"123";"2014-01-31"}') as ArrayValueObject;

            expect(arrayValueObject.toValue()).toStrictEqual([['123'], ['2014-01-31']]);
        });

        it('StringValueObject empty string converts to VALUE error for arithmetic coercion', () => {
            const number = StringValueObject.create('').convertToNumberObjectValue();

            expect(number.isError()).toBeTruthy();
            expect((number as ErrorValueObject).getErrorType()).toBe(ErrorType.VALUE);
        });

        it('ValueObjectFactory create ErrorValueObject ', () => {
            let errorValueObject = ValueObjectFactory.create(Number.NaN);

            expect(errorValueObject.isError()).toBeTruthy();

            errorValueObject = ValueObjectFactory.create(Number.POSITIVE_INFINITY);

            expect(errorValueObject.isError()).toBeTruthy();

            errorValueObject = ValueObjectFactory.create(Number.NEGATIVE_INFINITY);

            expect(errorValueObject.isError()).toBeTruthy();
        });
    });

    describe('Test DefaultValue', () => {
        it('After set defaultValue, use ', () => {
            const calculateValueList: Nullable<BaseValueObject>[][] = [[]];
            calculateValueList[0][1] = NumberValueObject.create(2);

            const arrayValueObject = ArrayValueObject.create({
                calculateValueList,
                rowCount: 2,
                columnCount: 2,
                unitId: '',
                sheetId: '',
                row: 0,
                column: 0,
            });

            arrayValueObject.setDefaultValue(BooleanValueObject.create(false));

            // getFirstCell
            expect(arrayValueObject.getFirstCell().getValue()).toStrictEqual(false);

            // getLastCell
            expect(arrayValueObject.getLastCell().getValue()).toStrictEqual(false);

            // iterator
            arrayValueObject.iterator(iterator);

            // iteratorReverse
            arrayValueObject.iteratorReverse(iterator);

            arrayValueObject.mapValue(mapValue);

            function iterator(valueObject: Nullable<BaseValueObject>, row: number, column: number) {
                if (!valueObject) {
                    return;
                }

                const value = valueObject.getValue();

                if (row === 0 && column === 0) {
                    expect(value).toStrictEqual(false);
                } else if (row === 0 && column === 1) {
                    expect(value).toStrictEqual(2);
                } else if (row === 1 && column === 0) {
                    expect(value).toStrictEqual(false);
                } else if (row === 1 && column === 1) {
                    expect(value).toStrictEqual(false);
                }
            }

            function mapValue(valueObject: Nullable<BaseValueObject>, row: number, column: number) {
                if (!valueObject) {
                    return ErrorValueObject.create(ErrorType.NA);
                }

                iterator(valueObject, row, column);

                return valueObject;
            }

            // flatten
            const flatten = arrayValueObject.flatten();
            expect(flatten.getFirstCell().getValue()).toStrictEqual(false);

            // slice
            const firstColumn = arrayValueObject.slice([0, 1], [0, 1]);
            if (!firstColumn) {
                throw new Error('firstColumn is null');
            }
            expect(firstColumn.getFirstCell().getValue()).toStrictEqual(false);

            // transpose
            const transpose = arrayValueObject.transpose();
            expect(transpose.getFirstCell().getValue()).toStrictEqual(false);
        });
    });
    describe('Test utils', () => {
        it('ArrayValueObject static createByArray', () => {
            const arrayValueObject = ArrayValueObject.createByArray([['cell1', 2, null], ['1', false, true]]);
            expect(arrayValueObject.toValue()).toStrictEqual([['cell1', 2, 0], [1, false, true]]);
        });
    });
});