node-opcua-address-space-for-conformance-testing 2.167.0 → 2.169.0

package/src/conformance_testing/access_right_variables.ts

@@ -0,0 +1,55 @@
+/**
+ * Access-right test variables for conformance testing.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+import { makeAccessLevelFlag } from "node-opcua-data-model";
+import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
+
+const defaultInt32Value = new Variant({
+    dataType: DataType.Int32,
+    arrayType: VariantArrayType.Scalar,
+    value: 36
+});
+
+const accessRightConfigs: {
+    name: string;
+    accessLevel: string;
+    userAccessLevel: string;
+    value?: Record<string, unknown>;
+}[] = [
+    { name: "AccessLevel_CurrentRead", accessLevel: "CurrentRead", userAccessLevel: "CurrentRead" },
+    { name: "AccessLevel_CurrentWrite", accessLevel: "CurrentWrite", userAccessLevel: "CurrentWrite", value: {} },
+    { name: "AccessLevel_CurrentRead_NotUser", accessLevel: "CurrentRead", userAccessLevel: "" },
+    { name: "AccessLevel_CurrentWrite_NotUser", accessLevel: "CurrentWrite | CurrentRead", userAccessLevel: "CurrentRead" },
+    { name: "AccessLevel_CurrentRead_NotCurrentWrite", accessLevel: "CurrentRead", userAccessLevel: "CurrentRead" },
+    { name: "AccessLevel_CurrentWrite_NotCurrentRead", accessLevel: "CurrentWrite", userAccessLevel: "CurrentWrite" },
+    { name: "AccessLevel_DeniedAll", accessLevel: "", userAccessLevel: "" }
+];
+
+export function addAccessRightVariables(namespace: Namespace, parentFolder: UAObject): void {
+    const accessRight_Folder = namespace.addFolder(parentFolder, {
+        browseName: "AccessRight",
+        description: "Folder containing various nodes with different access right behavior",
+        nodeId: "s=AccessRight"
+    });
+
+    const accessLevel_All_Folder = namespace.addFolder(accessRight_Folder, {
+        browseName: "AccessLevel",
+        description: "Various node with different access right behavior",
+        nodeId: "s=AccessLevel"
+    });
+
+    for (const config of accessRightConfigs) {
+        namespace.addVariable({
+            componentOf: accessLevel_All_Folder,
+            browseName: config.name,
+            description: { locale: "en", text: config.name },
+            nodeId: `s=${config.name}`,
+            dataType: "Int32",
+            valueRank: -1,
+            accessLevel: makeAccessLevelFlag(config.accessLevel),
+            userAccessLevel: makeAccessLevelFlag(config.userAccessLevel),
+            value: config.value ?? defaultInt32Value
+        });
+    }
+}

package/src/conformance_testing/analog_data_items.ts

@@ -0,0 +1,136 @@
+/**
+ * Analog data items, data items, and array analog data items for conformance testing.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+import { assert } from "node-opcua-assert";
+import { standardUnits } from "node-opcua-data-access";
+import { DataType, VariantArrayType } from "node-opcua-variant";
+
+interface RangeOptions {
+    low: number;
+    high: number;
+}
+
+function makeRange(dataType: DataType): { engineeringUnitsRange: RangeOptions; instrumentRange: RangeOptions } {
+    let engineeringUnitsRange = { low: -200, high: 200 };
+    let instrumentRange = { low: -200, high: 200 };
+    if (DataType[dataType][0] === "U" || dataType === DataType.Byte) {
+        engineeringUnitsRange = { low: 10, high: 250 };
+        instrumentRange = { low: 10, high: 250 };
+    }
+    return { engineeringUnitsRange, instrumentRange };
+}
+
+export function addAnalogDataItems(namespace: Namespace, parentFolder: UAObject): void {
+    function _addDataItem(localParentFolder: UAObject, dataType: DataType, initialValue: unknown): void {
+        const name = `${DataType[dataType]}DataItem`;
+        const nodeId = `s=${name}`;
+
+        const v = namespace.addDataItem({
+            componentOf: localParentFolder,
+            nodeId,
+            browseName: name,
+            definition: "(tempA -25) + tempB",
+            dataType,
+            value: {
+                arrayType: VariantArrayType.Scalar,
+                dataType,
+                value: initialValue
+            }
+        });
+        assert(v.nodeId.toString() === `ns=${namespace.index};${nodeId}`, `ns=${namespace.index};${nodeId} ${v.nodeId.toString()}`);
+    }
+
+    function _addAnalogDataItem(localParentFolder: UAObject, dataType: DataType, initialValue: unknown): void {
+        const { engineeringUnitsRange, instrumentRange } = makeRange(dataType);
+        assert(
+            Array.isArray(initialValue) ||
+                ((initialValue as number) >= engineeringUnitsRange.low && (initialValue as number) <= engineeringUnitsRange.high)
+        );
+        const name = `${DataType[dataType]}AnalogDataItem`;
+        const nodeId = `s=${name}`;
+
+        namespace.addAnalogDataItem({
+            componentOf: localParentFolder,
+            nodeId,
+            browseName: name,
+            definition: "...",
+            valuePrecision: 0.5,
+            engineeringUnitsRange,
+            instrumentRange,
+            engineeringUnits: standardUnits.degree_celsius,
+            dataType,
+            value: { arrayType: VariantArrayType.Scalar, dataType, value: initialValue }
+        });
+    }
+
+    function _addArrayAnalogDataItem(localParentFolder: UAObject, dataType: DataType, initialValue: unknown) {
+        const name = `${DataType[dataType]}ArrayAnalogDataItem`;
+        const nodeId = `s=${name}`;
+        const { engineeringUnitsRange, instrumentRange } = makeRange(dataType);
+
+        namespace.addAnalogDataItem({
+            componentOf: localParentFolder,
+            nodeId,
+            browseName: name,
+            definition: "(tempA -25) + tempB",
+            valuePrecision: 0.5,
+            engineeringUnitsRange,
+            instrumentRange,
+            engineeringUnits: standardUnits.degree_celsius,
+            dataType,
+            value: {
+                arrayType: VariantArrayType.Array,
+                dataType,
+                value: [initialValue, initialValue, initialValue, initialValue, initialValue]
+            }
+        });
+    }
+
+    const analogItemFolder = namespace.addObject({
+        organizedBy: parentFolder,
+        browseName: "Simulation_AnalogDataItem",
+        typeDefinition: "FolderType",
+        nodeId: "s=Simulation_AnalogDataItem"
+    });
+
+    const { engineeringUnitsRange, instrumentRange } = makeRange(DataType.Double);
+    namespace.addAnalogDataItem({
+        componentOf: analogItemFolder,
+        nodeId: "s=DoubleAnalogDataItemWithEU",
+        browseName: "DoubleAnalogDataItemWithEU",
+        definition: "(tempA -25) + tempB",
+        valuePrecision: 0.5,
+        engineeringUnitsRange,
+        instrumentRange,
+        engineeringUnits: standardUnits.degree_celsius,
+        dataType: DataType.Double,
+        value: { dataType: DataType.Double, value: 19.5 }
+    });
+
+    const data = [
+        { dataType: DataType.Double, value: 3.14 },
+        { dataType: DataType.Float, value: 3.14 },
+        { dataType: DataType.Int16, value: -10 },
+        { dataType: DataType.UInt16, value: 10 },
+        { dataType: DataType.Int32, value: -100 },
+        { dataType: DataType.UInt32, value: 100 },
+        { dataType: DataType.Int64, value: [0, 0] },
+        { dataType: DataType.UInt64, value: [0, 0] },
+        { dataType: DataType.Byte, value: 65 },
+        { dataType: DataType.SByte, value: -23 }
+    ];
+
+    for (const e of data) {
+        _addAnalogDataItem(analogItemFolder, e.dataType, e.value);
+    }
+    for (const e of data) {
+        _addDataItem(analogItemFolder, e.dataType, e.value);
+    }
+    _addDataItem(analogItemFolder, DataType.String, "some string");
+    _addDataItem(analogItemFolder, DataType.DateTime, new Date());
+
+    for (const e of data) {
+        _addArrayAnalogDataItem(analogItemFolder, e.dataType, e.value);
+    }
+}

package/src/conformance_testing/discrete_variables.ts

@@ -0,0 +1,131 @@
+/**
+ * Discrete variable types: TwoStateDiscrete, MultiStateDiscrete, MultiStateValueDiscrete.
+ */
+import type { Int64, UInt64 } from "node-opcua-basic-types";
+import type { Namespace, UAObject } from "node-opcua-address-space";
+
+function getDADiscreteTypeFolder(namespace: Namespace, parentFolder: UAObject): UAObject {
+    const name = "Simulation_DA_DiscreteType";
+    const nodeId = "s=Simulation_DA_DiscreteType";
+
+    let node = parentFolder.getFolderElementByName(name);
+    if (!node) {
+        node = namespace.addObject({
+            organizedBy: parentFolder,
+            typeDefinition: "FolderType",
+            browseName: name,
+            nodeId
+        });
+    }
+    return node as UAObject;
+}
+
+export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder: UAObject): void {
+    const DADiscreteTypeFolder = getDADiscreteTypeFolder(namespace, parentFolder);
+
+    const twoStateDiscrete001 = namespace.addTwoStateDiscrete({
+        organizedBy: DADiscreteTypeFolder,
+        nodeId: "s=TwoStateDiscrete001",
+        browseName: "TwoStateDiscrete001",
+        trueState: "Enabled",
+        falseState: "Disabled"
+    });
+
+    const twoStateDiscrete002 = namespace.addTwoStateDiscrete({
+        organizedBy: DADiscreteTypeFolder,
+        nodeId: "s=TwoStateDiscrete002",
+        browseName: "TwoStateDiscrete002",
+        trueState: "On",
+        falseState: "Off",
+        optionals: ["TransitionTime", "EffectiveDisplayName"]
+    });
+
+    const twoStateDiscrete003 = namespace.addTwoStateDiscrete({
+        browseName: "twoStateDiscrete003",
+        nodeId: "s=TwoStateDiscrete003",
+        optionals: ["TransitionTime"],
+        isTrueSubStateOf: twoStateDiscrete002
+    });
+
+    const twoStateDiscrete004 = namespace.addTwoStateDiscrete({
+        organizedBy: DADiscreteTypeFolder,
+        nodeId: "s=TwoStateDiscrete004",
+        browseName: "TwoStateDiscrete004",
+        trueState: "InProgress",
+        falseState: "Stopped"
+    });
+
+    const twoStateDiscrete005 = namespace.addTwoStateDiscrete({
+        organizedBy: DADiscreteTypeFolder,
+        nodeId: "s=TwoStateDiscrete005",
+        browseName: "TwoStateDiscrete005",
+        trueState: "InProgress",
+        falseState: "Stopped"
+    });
+
+    twoStateDiscrete001.setValueFromSource({ dataType: "Boolean", value: false });
+    twoStateDiscrete002.setValueFromSource({ dataType: "Boolean", value: false });
+    twoStateDiscrete003.setValueFromSource({ dataType: "Boolean", value: false });
+    twoStateDiscrete004.setValueFromSource({ dataType: "Boolean", value: false });
+    twoStateDiscrete005.setValueFromSource({ dataType: "Boolean", value: false });
+}
+
+export function addMultiStateDiscreteVariable(namespace: Namespace, parentFolder: UAObject): void {
+    const DADiscreteTypeFolder = getDADiscreteTypeFolder(namespace, parentFolder);
+
+    for (let i = 1; i <= 5; i++) {
+        const name = `MultiStateDiscrete${i.toString().padStart(3, "0")}`;
+        namespace.addMultiStateDiscrete({
+            organizedBy: DADiscreteTypeFolder,
+            nodeId: `s=${name}`,
+            browseName: name,
+            enumStrings: ["Red", "Orange", "Green"],
+            value: 1 // Orange
+        });
+    }
+}
+
+export function addMultiStateValueDiscreteVariables(namespaceDemo: Namespace, parentFolder: UAObject): void {
+    const multistateValueDiscreteTypeFolder = namespaceDemo.addObject({
+        organizedBy: parentFolder,
+        typeDefinition: "FolderType",
+        browseName: "Simulation_DA_MultiStateValueDiscreteType",
+        nodeId: "s=Simulation_DA_MultiStateValueDiscreteType"
+    });
+
+    function _add_multi_state_variable(
+        folder: UAObject,
+        dataType: string,
+        _value: number | UInt64 | Int64,
+        enumValues: Record<string, number>
+    ) {
+        const name = `${dataType}MultiStateValueDiscrete`;
+        const nodeId = `s=${name}`;
+
+        namespaceDemo.addMultiStateValueDiscrete({
+            organizedBy: folder,
+            browseName: name,
+            nodeId,
+            dataType,
+            enumValues,
+            value: 0x0000 // Zero
+        });
+    }
+
+    const enumValueUnsigned = { Zero: 0x00, One: 0x01, Two: 0x02, Three: 0x03, Four: 0x04, Five: 0x05, Six: 0x06, Seven: 0x07 };
+    const enumValueSigned = { MinusOne: -1, MinusTwo: -2, MinusThree: -3, ...enumValueUnsigned };
+
+    const data = [
+        { dataType: "Int16", value: -1, enumValue: enumValueSigned },
+        { dataType: "UInt16", value: 10, enumValue: enumValueUnsigned },
+        { dataType: "Int32", value: -1, enumValue: enumValueSigned },
+        { dataType: "UInt32", value: 100, enumValue: enumValueUnsigned },
+        { dataType: "Int64", value: [0, 0], enumValue: enumValueUnsigned },
+        { dataType: "UInt64", value: [0, 0], enumValue: enumValueSigned },
+        { dataType: "Byte", value: 1, enumValue: enumValueUnsigned },
+        { dataType: "SByte", value: -1, enumValue: enumValueSigned }
+    ];
+    for (const e of data) {
+        _add_multi_state_variable(multistateValueDiscreteTypeFolder, e.dataType, e.value, e.enumValue);
+    }
+}

package/src/conformance_testing/enumeration_variable.ts

@@ -0,0 +1,27 @@
+/**
+ * Enumeration type and variable for conformance testing.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+
+export function addEnumerationVariable(namespaceDemo: Namespace, parentFolder: UAObject): void {
+    const addressSpace = namespaceDemo.addressSpace;
+
+    const myEnumType = namespaceDemo.addEnumerationType({
+        browseName: "SimulationEnumerationType",
+        enumeration: [
+            { value: 1, displayName: "RUNNING" },
+            { value: 2, displayName: "BLOCKED" },
+            { value: 3, displayName: "IDLE" },
+            { value: 4, displayName: "UNDER MAINTENANCE" }
+        ]
+    });
+
+    const e = namespaceDemo.addVariable({
+        organizedBy: parentFolder,
+        propertyOf: (addressSpace.rootFolder.objects.server as unknown as Record<string, unknown>)
+            .vendorServerInfos as unknown as UAObject,
+        dataType: myEnumType,
+        browseName: "RunningState"
+    });
+    e.writeEnumValue("RUNNING");
+}

package/src/conformance_testing/helpers.ts

@@ -0,0 +1,226 @@
+/**
+ * Shared helper utilities for conformance testing address space construction.
+ */
+import type { Namespace, UAObject, UAVariable } from "node-opcua-address-space";
+import { assert } from "node-opcua-assert";
+import * as ec from "node-opcua-basic-types";
+import { randomString } from "node-opcua-basic-types";
+import { AccessLevelFlag, LocalizedText, makeAccessLevelFlag, QualifiedName } from "node-opcua-data-model";
+import { make_debugLog, make_warningLog } from "node-opcua-debug";
+import { findBuiltInType } from "node-opcua-factory";
+import { buildVariantArray, DataType, Variant, VariantArrayType } from "node-opcua-variant";
+
+const debugLog = make_debugLog(__filename);
+const warningLog = make_warningLog(__filename);
+
+// ─── Validators & Random Generators ─────────────────────────────────────
+
+function defaultValidator(/*value*/) {
+    return true;
+}
+
+export function getValidatorFuncForType(dataType: DataType): (value: unknown) => boolean {
+    const f = (ec as Record<string, unknown>)[`isValid${dataType}`];
+    return (f as (value: unknown) => boolean) || defaultValidator;
+}
+
+export function getRandomFuncForType(dataType: DataType): () => unknown {
+    const dataTypeName = DataType[dataType];
+    const f = (ec as Record<string, unknown>)[`random${dataTypeName}`];
+
+    if (f) {
+        return f as () => unknown;
+    }
+
+    switch (dataTypeName) {
+        case "Variant":
+            return () => {
+                return new Variant();
+            };
+        case "QualifiedName":
+            return () => {
+                return new QualifiedName({ name: randomString() });
+            };
+        case "LocalizedText":
+            return () => {
+                return new LocalizedText({ text: randomString() });
+            };
+        case "XmlElement":
+            return () => {
+                const element = randomString();
+                const content = randomString();
+                return `<${element}>${content}</${element}>`;
+            };
+        default:
+            // c8 ignore next
+            throw new Error(`Cannot find random${dataTypeName}() func anywhere`);
+    }
+}
+
+// ─── DataType Lookup ────────────────────────────────────────────────────
+
+export function findDataType(dataTypeName: string): DataType {
+    const builtInDataTypeName = findBuiltInType(dataTypeName);
+    const dataType = DataType[builtInDataTypeName.name as keyof typeof DataType];
+    // c8 ignore next
+    if (!dataType) {
+        throw new Error(` dataType ${dataTypeName} must exists`);
+    }
+    return dataType;
+}
+
+// ─── Validation ─────────────────────────────────────────────────────────
+
+function validate_value_or_array(isArray: boolean, variantValue: unknown, validatorFunc: (v: unknown) => boolean) {
+    assert(typeof validatorFunc === "function");
+    if (isArray) {
+        const arr = variantValue as ArrayLike<unknown>;
+        const n = Math.min(10, arr.length);
+        for (let i = 0; i < n; i++) {
+            // c8 ignore next
+            if (!validatorFunc(arr[i])) {
+                throw new Error(`default value must be valid for dataType ${variantValue} at index ${i} got ${arr[i]}`);
+            }
+        }
+    } else {
+        // c8 ignore next
+        if (!validatorFunc(variantValue)) {
+            throw new Error(`default value must be valid for dataType ${variantValue}`);
+        }
+    }
+}
+
+// ─── Variant Construction ───────────────────────────────────────────────
+
+export function makeVariant(dataTypeName: string, arrayType: VariantArrayType, dimensions: number[] | null, current_value: unknown) {
+    const dataType = findDataType(dataTypeName);
+    const validatorFunc = getValidatorFuncForType(dataType);
+    const isArray = arrayType === VariantArrayType.Array || arrayType === VariantArrayType.Matrix;
+    validate_value_or_array(isArray, current_value, validatorFunc);
+
+    return new Variant({
+        dataType,
+        arrayType,
+        dimensions,
+        value: current_value
+    });
+}
+
+// ─── Generic Variable Helpers ───────────────────────────────────────────
+
+export function addVariable(
+    namespace: Namespace,
+    parent: UAObject,
+    varName: string,
+    dataTypeName: string,
+    current_value: unknown,
+    valueRank: number,
+    arrayDimensions: number[] | null,
+    extra_name: string
+): UAVariable {
+    assert(typeof extra_name === "string");
+
+    const arrayType = valueRank <= 0 ? VariantArrayType.Scalar : valueRank === 1 ? VariantArrayType.Array : VariantArrayType.Matrix;
+    const variant = makeVariant(dataTypeName, arrayType, arrayDimensions, current_value);
+    const name = varName + extra_name;
+    const nodeId = `${parent.nodeId.toString()}_${varName}${extra_name}`;
+    const placeholder = { variant };
+
+    const variable = namespace.addVariable({
+        browseName: name,
+        componentOf: parent,
+        dataType: varName,
+        description: { locale: "en", text: name },
+        nodeId,
+        valueRank,
+        arrayDimensions,
+        accessLevel: makeAccessLevelFlag("CurrentRead | CurrentWrite"),
+        userAccessLevel: makeAccessLevelFlag("CurrentRead | CurrentWrite"),
+        value: variant
+    });
+    (variable as unknown as Record<string, unknown>)._backdoor_placeholder = placeholder;
+    return variable;
+}
+
+export function addScalarVariable(
+    namespace: Namespace,
+    parent: UAObject,
+    name: string,
+    realType: string,
+    default_value: unknown,
+    extra_name: string
+) {
+    assert(typeof extra_name === "string");
+    const initialValue = typeof default_value === "function" ? default_value() : default_value;
+    const variable = addVariable(namespace, parent, name, realType, initialValue, -1, null, extra_name);
+    assert(variable.valueRank === -1);
+    assert(variable.accessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.userAccessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.historizing === false);
+    return variable;
+}
+
+export function addArrayVariable(
+    namespace: Namespace,
+    parent: UAObject,
+    dataTypeName: string,
+    default_value: unknown,
+    realTypeName: string,
+    arrayLength: number,
+    extra_name: string
+): void {
+    assert(typeof dataTypeName === "string");
+    assert(typeof realTypeName === "string");
+
+    // c8 ignore next
+    if (!DataType[realTypeName as keyof typeof DataType]) {
+        warningLog("dataTypeName", dataTypeName);
+        warningLog("realTypeName", realTypeName);
+    }
+
+    assert(DataType[realTypeName as keyof typeof DataType], " expecting a valid real type");
+    arrayLength = arrayLength || 10;
+
+    const local_defaultValue = typeof default_value === "function" ? default_value() : default_value;
+    const current_value = buildVariantArray(DataType[realTypeName as keyof typeof DataType], arrayLength, local_defaultValue);
+    const variable = addVariable(namespace, parent, dataTypeName, realTypeName, current_value, 1, null, extra_name);
+
+    assert(variable.valueRank === 1);
+    assert(variable.accessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.userAccessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.historizing === false);
+}
+
+export function addMultiDimensionalArrayVariable(
+    namespace: Namespace,
+    parent: UAObject,
+    dataTypeName: string,
+    default_value: unknown,
+    realTypeName: string,
+    nbRows: number,
+    nbCols: number,
+    extra_name: string
+): void {
+    assert(typeof dataTypeName === "string");
+    assert(typeof realTypeName === "string");
+
+    // c8 ignore next
+    if (!DataType[realTypeName as keyof typeof DataType]) {
+        debugLog("dataTypeName", dataTypeName);
+        debugLog("realTypeName", realTypeName);
+    }
+
+    assert(DataType[realTypeName as keyof typeof DataType], " expecting a valid real type");
+
+    nbRows = nbRows || 6;
+    nbCols = nbCols || 2;
+
+    const local_defaultValue = typeof default_value === "function" ? default_value() : default_value;
+    const current_value = buildVariantArray(DataType[realTypeName as keyof typeof DataType], nbRows * nbCols, local_defaultValue);
+    const variable = addVariable(namespace, parent, dataTypeName, realTypeName, current_value, 2, [nbRows, nbCols], extra_name);
+
+    assert(variable.valueRank === 2);
+    assert(variable.accessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.userAccessLevel === AccessLevelFlag.CurrentRead + AccessLevelFlag.CurrentWrite);
+    assert(variable.historizing === false);
+}

package/src/conformance_testing/mass_variables.ts

@@ -0,0 +1,42 @@
+/**
+ * Mass variables: 100 items per supported data-type.
+ */
+import type { Namespace, UAObject } from "node-opcua-address-space";
+
+import { addVariable } from "./helpers";
+import { typeAndDefaultValue } from "./type_defaults";
+
+function addMassVariablesOfType(
+    namespace: Namespace,
+    parent: UAObject,
+    dataTypeName: string,
+    default_value: unknown,
+    realType: string
+): void {
+    const nodeName = `Scalar_Mass_${dataTypeName}`;
+
+    const scalarMass_Type = namespace.addObject({
+        browseName: nodeName,
+        description: "This folder will contain 100 items per supported data-type.",
+        nodeId: `s=${nodeName}`,
+        organizedBy: parent
+    });
+    for (let i = 0; i <= 99; i++) {
+        const extra_name = `_${i.toString().padStart(2, "0")}`;
+        const local_defaultValue = typeof default_value === "function" ? default_value() : default_value;
+        addVariable(namespace, scalarMass_Type, dataTypeName, realType, local_defaultValue, -1, null, extra_name);
+    }
+}
+
+export function addMassVariables(namespace: Namespace, scalarFolder: UAObject): void {
+    const scalarMass = namespace.addFolder(scalarFolder, {
+        browseName: "Scalar_Mass",
+        description: "This folder will contain 100 items per supported data-type.",
+        nodeId: "s=Scalar_Mass"
+    });
+
+    for (const e of typeAndDefaultValue) {
+        const realType = e.realType || e.type;
+        addMassVariablesOfType(namespace, scalarMass, e.type, e.defaultValue, realType);
+    }
+}