node-opcua-address-space-for-conformance-testing 2.180.0 → 2.181.0

package/src/conformance_testing/discrete_variables.ts

@@ -25,7 +25,7 @@ export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder:
     const DADiscreteTypeFolder = getDADiscreteTypeFolder(namespace, parentFolder);
 
     const twoStateDiscrete001 = namespace.addTwoStateDiscrete({
-        organizedBy: DADiscreteTypeFolder,
+        componentOf: DADiscreteTypeFolder,
         nodeId: "s=TwoStateDiscrete001",
         browseName: "TwoStateDiscrete001",
         trueState: "Enabled",
@@ -33,7 +33,7 @@ export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder:
     });
 
     const twoStateDiscrete002 = namespace.addTwoStateDiscrete({
-        organizedBy: DADiscreteTypeFolder,
+        componentOf: DADiscreteTypeFolder,
         nodeId: "s=TwoStateDiscrete002",
         browseName: "TwoStateDiscrete002",
         trueState: "On",
@@ -41,7 +41,9 @@ export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder:
         optionals: ["TransitionTime", "EffectiveDisplayName"]
     });
 
+    // HasTrueSubState is not hierarchical: the HasComponent reference keeps it browsable
     const twoStateDiscrete003 = namespace.addTwoStateDiscrete({
+        componentOf: DADiscreteTypeFolder,
         browseName: "twoStateDiscrete003",
         nodeId: "s=TwoStateDiscrete003",
         optionals: ["TransitionTime"],
@@ -49,7 +51,7 @@ export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder:
     });
 
     const twoStateDiscrete004 = namespace.addTwoStateDiscrete({
-        organizedBy: DADiscreteTypeFolder,
+        componentOf: DADiscreteTypeFolder,
         nodeId: "s=TwoStateDiscrete004",
         browseName: "TwoStateDiscrete004",
         trueState: "InProgress",
@@ -57,7 +59,7 @@ export function addTwoStateDiscreteVariables(namespace: Namespace, parentFolder:
     });
 
     const twoStateDiscrete005 = namespace.addTwoStateDiscrete({
-        organizedBy: DADiscreteTypeFolder,
+        componentOf: DADiscreteTypeFolder,
         nodeId: "s=TwoStateDiscrete005",
         browseName: "TwoStateDiscrete005",
         trueState: "InProgress",

package/src/conformance_testing/helpers.ts

@@ -5,14 +5,17 @@ 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 { AccessLevelFlag, DiagnosticInfo, LocalizedText, makeAccessLevelFlag, QualifiedName } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
 import { checkDebugFlag, 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 doDebug = checkDebugFlag(__filename);
-const warningLog = make_warningLog(__filename);
+import type { CustomExtensionObject } from "./custom_extension_object.js";
+
+const debugLog = make_debugLog("helpers");
+const doDebug = checkDebugFlag("helpers");
+const warningLog = make_warningLog("helpers");
 
 // ─── Validators & Random Generators ─────────────────────────────────────
 
@@ -25,7 +28,7 @@ export function getValidatorFuncForType(dataType: DataType): (value: unknown) =>
     return (f as (value: unknown) => boolean) || defaultValidator;
 }
 
-export function getRandomFuncForType(dataType: DataType): () => unknown {
+export function getRandomFuncForType(dataType: DataType, custom?: CustomExtensionObject): () => unknown {
     const dataTypeName = DataType[dataType];
     const f = (ec as Record<string, unknown>)[`random${dataTypeName}`];
 
@@ -35,9 +38,26 @@ export function getRandomFuncForType(dataType: DataType): () => unknown {
 
     switch (dataTypeName) {
         case "Variant":
+            // the value of a Variant-typed variable is itself a Variant
+            return () => {
+                return new Variant({ dataType: DataType.Double, value: Math.random() * 100 });
+            };
+        case "DataValue":
+            return () => {
+                return new DataValue({
+                    value: new Variant({ dataType: DataType.Double, value: Math.random() * 100 }),
+                    sourceTimestamp: new Date()
+                });
+            };
+        case "DiagnosticInfo":
             return () => {
-                return new Variant();
+                return new DiagnosticInfo({ additionalInfo: randomString() });
             };
+        case "ExtensionObject":
+            // the one type with no namespace-zero answer: without a concrete
+            // structure from the caller the only valid value is a null
+            // ExtensionObject, which never changes - see ./custom_extension_object.ts
+            return custom ? () => custom.random() : () => null;
         case "QualifiedName":
             return () => {
                 return new QualifiedName({ name: randomString() });

package/src/conformance_testing/mass_variables.ts

@@ -3,8 +3,9 @@
  */
 import type { Namespace, UAObject } from "node-opcua-address-space";
 
-import { addVariable } from "./helpers";
-import { typeAndDefaultValue } from "./type_defaults";
+import { type CustomExtensionObject, initialValueFor } from "./custom_extension_object.js";
+import { addVariable } from "./helpers.js";
+import { typeAndDefaultValue } from "./type_defaults.js";
 
 function addMassVariablesOfType(
     namespace: Namespace,
@@ -28,7 +29,7 @@ function addMassVariablesOfType(
     }
 }
 
-export function addMassVariables(namespace: Namespace, scalarFolder: UAObject): void {
+export function addMassVariables(namespace: Namespace, scalarFolder: UAObject, custom?: CustomExtensionObject): void {
     const scalarMass = namespace.addFolder(scalarFolder, {
         browseName: "Scalar_Mass",
         description: "This folder will contain 100 items per supported data-type.",
@@ -37,6 +38,6 @@ export function addMassVariables(namespace: Namespace, scalarFolder: UAObject):
 
     for (const e of typeAndDefaultValue) {
         const realType = e.realType || e.type;
-        addMassVariablesOfType(namespace, scalarMass, e.type, e.defaultValue, realType);
+        addMassVariablesOfType(namespace, scalarMass, e.type, initialValueFor(e, custom), realType);
     }
 }

package/src/conformance_testing/path_and_large_arrays.ts

@@ -3,8 +3,9 @@
  */
 import type { Namespace, UAObject } from "node-opcua-address-space";
 
-import { addArrayVariable } from "./helpers";
-import { typeAndDefaultValue } from "./type_defaults";
+import { type CustomExtensionObject, initialValueFor } from "./custom_extension_object.js";
+import { addArrayVariable } from "./helpers.js";
+import { typeAndDefaultValue } from "./type_defaults.js";
 
 export function addPath10Deep(namespace: Namespace, simulation_folder: UAObject) {
     let parent = simulation_folder;
@@ -21,7 +22,7 @@ export function addPath10Deep(namespace: Namespace, simulation_folder: UAObject)
     }
 }
 
-export function addVeryLargeArrayVariables(namespace: Namespace, objectsFolder: UAObject): void {
+export function addVeryLargeArrayVariables(namespace: Namespace, objectsFolder: UAObject, custom?: CustomExtensionObject): void {
     const scalarStaticLargeArray = namespace.addObject({
         organizedBy: objectsFolder,
         browseName: "Static_Scalar_Large_Array",
@@ -30,6 +31,6 @@ export function addVeryLargeArrayVariables(namespace: Namespace, objectsFolder:
     });
     for (const e of typeAndDefaultValue) {
         const realType = e.realType || e.type;
-        addArrayVariable(namespace, scalarStaticLargeArray, e.type, e.defaultValue, realType, 50 * 1024, "");
+        addArrayVariable(namespace, scalarStaticLargeArray, e.type, initialValueFor(e, custom), realType, 50 * 1024, "");
     }
 }

package/src/conformance_testing/simulation_variables.ts

@@ -6,10 +6,11 @@ import { assert } from "node-opcua-assert";
 import { isValidBoolean, isValidUInt16 } from "node-opcua-basic-types";
 import { DataType, Variant, VariantArrayType } from "node-opcua-variant";
 
-import { addVariable, findDataType, getRandomFuncForType } from "./helpers";
-import { typeAndDefaultValue } from "./type_defaults";
+import { type CustomExtensionObject, initialValueFor } from "./custom_extension_object.js";
+import { addVariable, findDataType, getRandomFuncForType } from "./helpers.js";
+import { typeAndDefaultValue } from "./type_defaults.js";
 
-export function addSimulationVariables(namespace: Namespace, scalarFolder: UAObject): void {
+export function addSimulationVariables(namespace: Namespace, scalarFolder: UAObject, custom?: CustomExtensionObject): void {
     let values_to_change: { dataType: DataType; randomFunc: () => unknown; variable: UAVariable }[] = [];
 
     function add_simulation_variable(
@@ -20,7 +21,7 @@ export function addSimulationVariables(namespace: Namespace, scalarFolder: UAObj
     ): UAVariable {
         realTypeName = realTypeName || dataTypeName;
         const dataType = findDataType(realTypeName);
-        const randomFunc = getRandomFuncForType(dataType);
+        const randomFunc = getRandomFuncForType(dataType, custom);
 
         // c8 ignore next
         if (typeof randomFunc !== "function") {
@@ -41,9 +42,8 @@ export function addSimulationVariables(namespace: Namespace, scalarFolder: UAObj
 
     for (const e of typeAndDefaultValue) {
         const dataType = e.type;
-        const defaultValue = typeof e.defaultValue === "function" ? e.defaultValue() : e.defaultValue;
         const realType = e.realType || dataType;
-        add_simulation_variable(simulation, dataType, defaultValue, realType);
+        add_simulation_variable(simulation, dataType, initialValueFor(e, custom), realType);
     }
 
     // Management nodes

package/src/conformance_testing/static_variables.ts

@@ -7,12 +7,22 @@ import type { Namespace, UAObject, UAVariable } from "node-opcua-address-space";
 import { make_errorLog } from "node-opcua-debug";
 import { DataType, Variant } from "node-opcua-variant";
 
-import { addArrayVariable, addMultiDimensionalArrayVariable, addScalarVariable } from "./helpers";
-import { typeAndDefaultValue } from "./type_defaults";
+import { type CustomExtensionObject, initialValueFor } from "./custom_extension_object.js";
+import { addArrayVariable, addMultiDimensionalArrayVariable, addScalarVariable } from "./helpers.js";
+import { typeAndDefaultValue } from "./type_defaults.js";
 
-const errorLog = make_errorLog(__filename);
+const errorLog = make_errorLog("static_variables");
 
-export async function addStaticVariables(namespace: Namespace, scalarFolder: UAObject): Promise<void> {
+// The one place this module learns where it sits on disk. `import.meta.dirname`
+// cannot be used while this package emits CommonJS (TS1470), so the ESM migration
+// has this single line to change rather than several scattered uses.
+const here = __dirname;
+
+export async function addStaticVariables(
+    namespace: Namespace,
+    scalarFolder: UAObject,
+    custom?: CustomExtensionObject
+): Promise<void> {
     const staticScalarFolder = namespace.addObject({
         organizedBy: scalarFolder,
         browseName: "Scalars",
@@ -24,13 +34,16 @@ export async function addStaticVariables(namespace: Namespace, scalarFolder: UAO
     for (const e of typeAndDefaultValue) {
         const dataType = e.type;
         const realType = e.realType || dataType;
-        const defaultValue = typeof e.defaultValue === "function" ? e.defaultValue() : e.defaultValue;
-        addScalarVariable(namespace, staticScalarFolder, dataType, realType, defaultValue, "");
+        addScalarVariable(namespace, staticScalarFolder, dataType, realType, initialValueFor(e, custom), "");
     }
 
+    // The two Description properties View Minimum Continuation Point 01 012 needs
+    // now live on the node that actually serves Static/All Profiles/Scalar/Bool -
+    // see addBooleanScalarAndArray() in ctt_folder.ts.
+
     // Load images
     async function setImage(imageType: string, filename: string): Promise<void> {
-        const fullPath = path.join(__dirname, "../../data", filename);
+        const fullPath = path.join(here, "../../data", filename);
         const imageNode = namespace.findNode(`s=Static_Scalar_Image${imageType}`) as UAVariable;
         try {
             const data = await fs.promises.readFile(fullPath);
@@ -55,7 +68,7 @@ export async function addStaticVariables(namespace: Namespace, scalarFolder: UAO
     });
     for (const e of typeAndDefaultValue) {
         const realType = e.realType || e.type;
-        addArrayVariable(namespace, staticArraysFolders, e.type, e.defaultValue, realType, 10, "");
+        addArrayVariable(namespace, staticArraysFolders, e.type, initialValueFor(e, custom), realType, 10, "");
     }
 
     // Multi-dimensional array variables
@@ -68,6 +81,15 @@ export async function addStaticVariables(namespace: Namespace, scalarFolder: UAO
     });
     for (const e of typeAndDefaultValue) {
         const realType = e.realType || e.type;
-        addMultiDimensionalArrayVariable(namespace, staticMultiDimensionalArrays, e.type, e.defaultValue, realType, 2, 3, "");
+        addMultiDimensionalArrayVariable(
+            namespace,
+            staticMultiDimensionalArrays,
+            e.type,
+            initialValueFor(e, custom),
+            realType,
+            2,
+            3,
+            ""
+        );
     }
 }

package/src/conformance_testing/type_defaults.ts

@@ -4,8 +4,10 @@
 
 import * as ec from "node-opcua-basic-types";
 import { emptyGuid } from "node-opcua-basic-types";
-import { LocalizedText, QualifiedName } from "node-opcua-data-model";
+import { DiagnosticInfo, LocalizedText, QualifiedName } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
 import { coerceNodeId } from "node-opcua-nodeid";
+import { DataType, Variant } from "node-opcua-variant";
 
 export const typeAndDefaultValue = [
     { type: "Boolean", defaultValue: false },
@@ -57,5 +59,32 @@ export const typeAndDefaultValue = [
     { type: "ImageBMP", realType: "ByteString", defaultValue: null },
     { type: "ImageGIF", realType: "ByteString", defaultValue: null },
     { type: "ImageJPG", realType: "ByteString", defaultValue: null },
-    { type: "ImagePNG", realType: "ByteString", defaultValue: null }
+    { type: "ImagePNG", realType: "ByteString", defaultValue: null },
+    // The last four built-in types. `type` is the browse name *and* the DataType
+    // attribute, so it has to be a DataType the address space can resolve, while
+    // `realType` names the built-in encoding of the value. Two of them differ:
+    // the Variant DataType node is BaseDataType (i=24) and the ExtensionObject
+    // one is Structure (i=22) - "Variant" and "ExtensionObject" are encodings,
+    // not browse names, and addVariable() rejects them as DataTypes.
+    {
+        type: "BaseDataType",
+        realType: "Variant",
+        defaultValue() {
+            return new Variant({ dataType: DataType.Double, value: 0.0 });
+        }
+    },
+    // a null ExtensionObject: TypeId 0, no body - what an unassigned Structure is
+    { type: "Structure", realType: "ExtensionObject", defaultValue: null },
+    {
+        type: "DataValue",
+        defaultValue() {
+            return new DataValue({ value: new Variant({ dataType: DataType.Double, value: 0.0 }) });
+        }
+    },
+    {
+        type: "DiagnosticInfo",
+        defaultValue() {
+            return new DiagnosticInfo({});
+        }
+    }
 ];

package/src/index.ts

@@ -1 +1 @@
-export * from "./address_space_for_conformance_testing";
+export * from "./address_space_for_conformance_testing.js";