Function doSingleTestDeal

test/ut/spec/scale/interval.test.ts:146–205

(
            extent: number[],
            splitNumber: number,
            fixMinMax: boolean
        )

        }

        function doSingleTestDeal(
            extent: number[],
            splitNumber: number,
            fixMinMax: boolean
        ): void {
            const span = extent[1] - extent[0];
            const result = intervalScaleNiceTicks(extent, span, splitNumber);
            const intervalPrecision = result.intervalPrecision;
            const resultInterval = result.interval;
            const niceTickExtent = result.niceTickExtent;

            expect(resultInterval).toBeFinite();
            expect(intervalPrecision).toBeFinite();
            expect(niceTickExtent[0]).toBeFinite();
            expect(niceTickExtent[1]).toBeFinite();

            expect(niceTickExtent[0]).toBeGreaterThanOrEqual(extent[0]);
            expect(niceTickExtent[1]).toBeLessThanOrEqual(extent[1]);
            expect(niceTickExtent[1]).toBeGreaterThanOrEqual(niceTickExtent[1]);
            expect(niceTickExtent[0] - niceTickExtent[1] <= resultInterval);

            const intervalScale = new IntervalScale();
            const option: ValueAxisBaseOption = {
                splitNumber: splitNumber
            };
            if (fixMinMax) {
                option.min = extent[0];
                option.max = extent[1];
            }
            const axisModel = new CartesianAxisModel(option, null, null);
            scaleCalcNice2(
                intervalScale,
                axisModel as AxisBaseModel<NumericAxisBaseOptionCommon>,
                null,
                null,
                extent
            );

            const ticks = intervalScale.getTicks();

            expect(ticks.length > 1);

            if (fixMinMax) {
                expect(ticks[0].value).toEqual(extent[0]);
                expect(ticks[ticks.length - 1].value).toEqual(extent[1]);
            }
            else {
                expect(ticks[0].value).toBeLessThanOrEqual(extent[0]);
                expect(ticks[ticks.length - 1].value).toBeGreaterThanOrEqual(extent[1]);
            }

            for (let i = 1; i < ticks.length; i++) {
                expect(ticks[i - 1].value).not.toBeGreaterThanOrEqual(ticks[i].value);

                if (ticks[i].value !== extent[0] && ticks[i].value !== extent[1]) {
                    const tickPrecision = getPrecisionSafe(ticks[i].value);
                    expect(tickPrecision).not.toBeGreaterThan(intervalPrecision);
                }