web/js/dataTypes.test.js - master - vladlevin790/cpp-lab-2

web/js/dataTypes.test.js
144 строки5 KB
vladlevin790
init
05 май 2026, 21:32
05 май 2026, 21:323310cbd
import {
    DATA_TYPES,
    buildAsciiPreviewFromState,
    canRunMean,
    canRunShift,
    formatMeanResult,
    getInsertLabel,
    getRemoveLabel,
    getTypeMeta,
    getValuePlaceholder
} from "./dataTypes.js";

describe("data type UI rules", () => {
    test.each([
        ["Array", "ru", "Добавить", "Удалить"],
        ["Vector", "ru", "Добавить", "Удалить"],
        ["Array", "en", "Add", "Remove"],
        ["Vector", "en", "Add", "Remove"],
        ["Stack", "ru", "Push", "Pop"],
        ["Stack", "en", "Push", "Pop"],
        ["Queue", "ru", "Enqueue", "Dequeue"],
        ["Queue", "en", "Enqueue", "Dequeue"],
        ["Unknown", "ru", "Добавить", "Удалить"],
        ["Unknown", "en", "Add", "Remove"]
    ])("uses structure-specific labels for %s/%s", (structure, language, insert, remove) => {
        expect(getInsertLabel(structure, language)).toBe(insert);
        expect(getRemoveLabel(structure, language)).toBe(remove);
    });

    test.each([
        ["int", "ru", "42"],
        ["int", "en", "42"],
        ["long", "ru", "9223372036854775807"],
        ["long", "en", "9223372036854775807"],
        ["double", "ru", "3.14"],
        ["double", "en", "3.14"],
        ["char", "ru", "A"],
        ["char", "en", "A"],
        ["string", "ru", "любой текст"],
        ["string", "en", "any text"],
        ["unknown", "ru", "42"],
        ["unknown", "en", "42"]
    ])("maps placeholder for %s/%s", (type, language, placeholder) => {
        expect(getValuePlaceholder(type, language)).toBe(placeholder);
    });

    test.each([
        ["int", true, true],
        ["long", true, true],
        ["double", false, true],
        ["char", false, false],
        ["string", false, false],
        ["unknown", true, true]
    ])("maps algorithm support for %s", (type, shift, mean) => {
        const meta = getTypeMeta(type);
        expect(meta.supportsShift).toBe(shift);
        expect(meta.supportsMean).toBe(mean);
        expect(canRunShift({ dataType: type, supportsShift: shift })).toBe(shift);
        expect(canRunMean({ dataType: type, supportsMean: mean })).toBe(mean);
    });

    test.each([
        [0, "0.0000"],
        [1, "1.0000"],
        [7 / 3, "2.3333"],
        [-2.5, "-2.5000"],
        [123456.78901, "123456.7890"]
    ])("formats numeric mean %s", (value, expected) => {
        expect(formatMeanResult(value)).toBe(expected);
    });

    test.each([Number.NaN, "3", undefined, null, {}, []])("rejects invalid mean %p", (value) => {
        expect(formatMeanResult(value)).toBe("—");
    });

    test.each([
        [0, "NUL", "control"],
        [7, "BEL", "control"],
        [9, "TAB", "control"],
        [10, "LF", "control"],
        [12, "FF", "control"],
        [13, "CR", "control"],
        [27, "ESC", "control"],
        [31, "US", "control"],
        [32, " ", "printable"],
        [48, "0", "printable"],
        [65, "A", "printable"],
        [90, "Z", "printable"],
        [97, "a", "printable"],
        [126, "~", "printable"],
        [127, "DEL", "control"],
        [128, "OUT", "out"],
        [-1, "OUT", "out"],
        [256, "OUT", "out"]
    ])("builds ASCII item for int value %s", (value, char, kind) => {
        const preview = buildAsciiPreviewFromState({
            dataType: "int",
            items: [{ index: 0, value: String(value) }]
        });

        expect(preview.items[0]).toMatchObject({
            index: 0,
            value: String(value),
            code: String(value),
            char,
            kind
        });
    });

    test.each([
        ["A", "65", "A"],
        ["Я", "1071", "Я"],
        ["", "", "EMPTY"]
    ])("builds ASCII item for char %p", (value, code, char) => {
        const preview = buildAsciiPreviewFromState({
            dataType: "char",
            items: [{ index: 2, value }]
        });

        expect(preview.items[0]).toMatchObject({ index: 2, value, code, char });
    });

    test.each([
        ["hello", "104", "h"],
        ["Привет", "1055", "П"],
        ["", "", "EMPTY"]
    ])("builds ASCII item for string %p", (value, code, char) => {
        const preview = buildAsciiPreviewFromState({
            dataType: "string",
            items: [{ index: 3, value }]
        });

        expect(preview.items[0]).toMatchObject({ index: 3, value, code, char });
    });

    test("exports long type metadata", () => {
        expect(DATA_TYPES.long).toEqual({
            label: "long",
            placeholder: "9223372036854775807",
            supportsShift: true,
            supportsMean: true
        });
    });
});