mirror of
https://github.com/OPCFoundation/UA-.NETStandard.git
synced 2026-10-19 07:02:16 +08:00
romanett
442889cba5
# Description
This PR fixes a bug audit of the source generation projects
(`tools/Opc.Ua.SourceGeneration*`: model loading, NodeSet import, all
emitters, the Roslyn hosts and packaging). It also fixes a max-effort
code review of those fixes, and a check of every spec-relevant change
against the OPC UA 1.05 text.
- **Scope:** about 85 audit findings, 48 review findings and 32
spec-grounding items were addressed. Each fix has a regression test that
fails without it.
- **Wire change:** it includes one deliberate, stack-wide wire change:
**structure-field matrices now follow OPC 10000-6 5.2.5 Table 28**.
Most changes are internal correctness fixes. The sections below list
every change a user can observe: wire formats, generated code and API,
generated address-space content, diagnostics and runtime behaviour.
## Behaviour / user-facing changes
### Wire format (encoders)
- **Binary inline matrices** (OPC 10000-6 5.2.5 Table 28).
- **Layout:** a multi-dimensional *structure field* is encoded as
`Int32[] Dimensions`, then the values **without a length prefix**, with
at least 2 dimensions.
- **Empty and null:** any dimension <= 0 means no values follow, and a
null matrix is `-1`. An empty matrix is written as `[0,0]`.
- **Compatibility:** this is **not compatible with earlier builds of
this SDK** for matrix fields. It applies to generated types,
`[DataType]` types, `Structure`, client ComplexTypes and
`WriteEncodeableMatrix`.
- **Unchanged:** Variant matrices (5.2.2.16) keep their old encoding.
- **Declared rank decides matrix vs array.** A 1-D `MatrixOf<T>` in an
array field or a Variable value is written as an array again.
Matrix-declared fields go through the new public
`EncoderExtensions.WriteInlineMatrixValue`, which generated code also
uses. A non-empty 1-D value in a matrix field throws `BadEncodingError`.
- **Decoder hardening:**
- Before allocating, the decoder bounds all matrix dimensions against
overflow, `MaxArrayLength` and the remaining message length.
- The decoder rejects:
- a matrix with fewer than 2 dimensions;
- a populated matrix whose rank differs from the field's declared rank;
- a union SwitchField greater than the number of fields;
- an EncodingMask with unassigned bits set.
- **Encoder `MaxArrayLength`:** the encoder enforces `MaxArrayLength`
for inline matrices, as it already did for arrays.
- **XML structure fields** (5.3.1, 5.3.4, 5.3.5).
- **Fields:** `Structure` and client ComplexTypes write fields like
typed fields (`<A>1</A>`, array elements directly) instead of a Variant
body.
- **Matrix fields:** `Dimensions` and `Elements` go directly inside the
field element, with no `<Matrix>` wrapper.
- **Empty matrices:** written as nil, because XML dimensions must be
greater than 0.
- **Compatibility:** decoders still accept the old shapes.
- **Enum fixes:** enum array elements with value 0 are no longer
dropped, and enum array element names are fixed.
- **Other encoding fixes:**
- A null `DiagnosticInfo` structure field writes `0x00` instead of
nothing.
- A null scalar field in a runtime `Structure` is written as its default
instead of zero bytes, which used to shift every following field.
- A Variant holding an empty matrix encodes as an empty array instead of
throwing.
- `Variant.Copy` keeps the matrix identity of null and empty matrices.
- **NodeSet export and the DataContract surrogate** write Variable
values with the Variant rules again. A null or empty `MatrixOf` variable
no longer produces invalid XML or unreadable NodeSets.
- **`JsonEncoder.CanOmitFields`** is `true` only for Compact encoding.
Verbose and RawData JSON include default-valued fields.
### `[DataType]` source-generated types
- **Default-value handling** (OPC 10000-6 5.4.1, Table 1).
- **Encode:** a field is omitted only when its value *and* its declared
default are the type's default (0, false, null). Fields with a
non-default initializer or constructor default, and empty strings, are
always written, so configuration files get slightly larger.
- **JSON decode:** a field missing from JSON decodes to the type
default.
- **XML decode:** a field missing from XML keeps its declared default,
which older configuration files rely on.
- **Why:** this fixes silent round-trip loss, for example
`SamplingInterval = 0` read back as `-1`.
- **Nested `[DataType]` types:** they are now generated inside their
containing types. Without an explicit id, their default TypeId and
XmlName are qualified (e.g. `s=Outer.Foo`); **wire identity change** for
nested types. Colliding activator names get a `_2` suffix.
- **Activators:** they are `internal` when the type, or any containing
type, is not public (was CS0060).
- **Matrix properties:**
- `MatrixOf<T>` properties use the inline matrix encoding.
- Matrices of non-sealed structures, or with
`StructureHandling.ExtensionObject`, are written as ExtensionObjects.
- Their published ValueRank is 2, because the rank can't be known from
`MatrixOf<T>`.
- **Published StructureDefinitions:**
- They include base-class fields.
- Nullable properties are no longer marked optional.
- Inline structure fields name their concrete type.
- **`[Flags]` enums:** they are published as plain enumerations with
their member values, which matches how they are encoded.
- **Other generated code:**
- `Clone` deep-copies arrays and matrices of structures, Variants,
ExtensionObjects and DataValues.
- `IsEqual` and `GetHashCode` are consistent: EncodingMask, active union
member and NaN handling agree.
- Pooled `Reuse()` restores the freshly constructed state through the
new `protected virtual ResetForReuse()`, and returns an instance to its
runtime type's pool.
- **Enum capture:** enum member values are captured culture-invariantly.
Negative values were lost on cultures that use U+2212 as the minus sign.
### Model-driven generator: generated code, API and file names
- **Removed API:** generated `*_Placeholder` proxy accessors (e.g.
`PowerTrainTypeClient.GetMotorIdentifier_PlaceholderAsync`) and fluent
`X_Placeholder()` accessors are removed; they could never resolve
anything.
- Proxy accessors now look children up by BrowseName with the right
namespace.
- `RoboticsClient` finds motors and gears by type and drives via
`IsDrivenBy`. Its topology snapshots used to be empty.
- **Renamed files:** generated files for a bound `[NodeManager]` are now
named `{Namespace}.{Class}.NodeManager.g.cs` (also `.Factory` and
`.FluentBuilders`).
- **Generated NodeState code:**
- Attributes are set through `baseState`/`nodeState` locals, so children
named like base attributes (e.g. `DataType`, `EventNotifier`) compile.
- Children that hide base members are declared `public new`, using names
reflected from the runtime.
- `global::` qualification is used throughout.
- **Proxies and fluent builders:** a proxy whose supertype is excluded
(e.g. Draft) derives from the nearest emitted ancestor. Fluent wrappers
and NodeState factories fall back the same way; they used to fail with
CS0246.
- **Derived structures:**
- The optional-field `EncodingMask` continues across inheritance.
- A derived structure over a base type from another model no longer
relies on `base.ResetForReuse`.
- **Default values:**
- NodeId, QualifiedName and ExpandedNodeId defaults resolve by namespace
URI (`context.NamespaceUris.GetIndexOrAppend`) and server URI.
- StatusCode, negative enum, `double`/`float` (shortest round-trip
literal) and escaped string defaults now compile.
- **Event records:**
- Vendor event records have `Decoder.GetStandardFields(NamespaceTable)`,
and their browse paths use the model's namespace.
- A field whose namespace is unknown to the session no longer matches a
namespace-0 field.
- Companion `StandardFields` is `[Obsolete]`.
- Vendor simple subtypes such as `Percent : Double` map to their
built-in type.
- **Other fixes:**
- `MethodState.CallAsync` passes the real `objectId` to synchronous
`OnCallMethod2` handlers; it used to pass `NodeId.Null`.
- Enumeration fields with an explicit `Identifier` keep it, instead of
taking a trailing `_<digits>`.
- Explicit NumericIds are no longer reused by automatic numbering.
- Dependencies are loaded in topological order.
### Generated address-space content
- **Arguments:**
- Methods without arguments no longer get empty
`InputArguments`/`OutputArguments` properties (OPC 10000-3 5.7).
- About 2,660 automatically assigned namespace-0 NodeIds of 15000 and
above shift. Every NodeId in `StandardTypes.csv` is unchanged.
- **Permissions:** type nodes and method declarations on types now carry
the model's `RolePermissions`/`AccessRestrictions`.
- **Restored nodes:** NodeSet import keeps nodes that were silently
dropped before:
- `NamespaceMetadata` objects and the NodeSet's own TypeDictionary
variables;
- ISA95 placeholders linked only non-hierarchically;
- instances whose parent is in another namespace.
- **Import details:**
- ValueRank > 1 without ArrayDimensions keeps its rank.
- `svr=` indexes map correctly.
- Invalid MinimumSamplingInterval values import as -1, not 0.
- Localized texts prefer the invariant or English translation.
- **StructureDefinitions:**
- They include inherited fields, including for subtypes without their
own fields (e.g. `AnonymousIdentityToken` now publishes PolicyId).
- The StructureType kind covers inherited AllowSubTypes fields.
- Unions ignore IsOptional.
- StructureFields never publish ValueRank 0; a OneOrMoreDimensions field
without dimensions becomes rank 2.
- Fields with ValueRank -2/-3 are published as scalar BaseDataType,
which is what is on the wire.
- **OptionSets:**
- Implicit fields get the next free bit.
- `OptionSetValues` uses null for undefined bits instead of "Reserved",
and structure OptionSets publish all their bits (no 32/96-bit cap).
- Numeric OptionSets are limited to their base type's width, and UInt64
bit 63 works.
- **Schemas:**
- Structures with inline-matrix fields are left out of the `.bsd`
(5.2.5).
- In the BSD, Variant-encoded and non-structure subtyped fields are
described as `ua:Variant`.
- In the `.xsd`, matrix fields are typed `ua:Matrix` with
`Dimensions`/`Elements`, and `EncodingMask` is required.
### NodeSet / model input handling
- **Model selection:**
- The newest NodeSet of a model is chosen by `ModelVersion` (SemVer 2.0
precedence), then PublicationDate. The `Version` attribute, which Annex
F says is not for comparison, is only a tie-break.
- The order is total and does not depend on input order; referenced
assemblies use the same rule.
- **Default names:**
- Invalid default Name/Prefix values are repaired (`201301ISA95` becomes
`_201301ISA95`, `class` becomes `class_`).
- Valid names are unchanged.
- Sanitising no longer depends on the OS.
- **`ModelUri` metadata** that doesn't match the NodeSet raises a
warning instead of silently losing the model.
- **Input detection:**
- Only XML files whose root is `ModelDesign` or `UANodeSet` are treated
as models.
- A malformed NodeSet stays a NodeSet input, so it no longer breaks the
ModelDesign pass.
- **`IdentifierFile` paths:** they are normalized (`./`, `../`), and the
suffix match requires a folder boundary.
- **Dependency payloads** (`ModelDependencyV1`) carry field IsOptional,
AllowSubTypes, ArrayDimensions and the producer's namespace tables in
skippable trailers, so old and new readers stay compatible.
### Roslyn host, diagnostics, packaging
- **New diagnostics:**
- MODELGEN036: `[NodeManager]` target not supported (nested, generic,
file-local or global namespace).
- MODELGEN037: `[DataType]` target not supported (struct, generic,
abstract, file-local or global namespace).
- MODELGEN038: the definition of an encodeable base type can't be found.
- **New validator errors:**
- a structure with both optional and subtyped fields (OPC 10000-6 F.13);
- multi-bit or duplicate OptionSet masks.
- **Diagnostic locations:** `[DataType]`/`[NodeManager]` diagnostics
point at real source locations again, so `#pragma` and `.editorconfig`
apply. MODELGEN010 is the exception.
- **Incremental caching:** pipeline values compare by value, so
unrelated edits no longer regenerate the whole model or all
`[DataType]`s.
- **`ModelSourceGeneratorIgnore`** on a ModelDesign input is honoured;
the design still resolves as a dependency.
- **Cancellation:** a cancelled generation run propagates
`OperationCanceledException` instead of reporting a MODELGEN003 error.
- **Stack package:** the `Stack` NuGet package now ships
`build/OPCFoundation.NetStandard.Opc.Ua.SourceGeneration.Stack.props`,
so `StackSourceGeneratorMode` and `StackSourceGeneratorExclude` reach
the compiler.
## Related Issues
- No tracking issue. The audit, review and spec-grounding reports are
available on request. Contains the matrix wire-format change discussed
for D-5 (OPC 10000-6 5.2.5 Table 28).
## Checklist
- [ ] I have signed the
[CLA](https://opcfoundation.org/license/cla/ContributorLicenseAgreementv1.0.pdf)
and read the
[CONTRIBUTING](https://github.com/OPCFoundation/UA-.NETStandard/blob/master/CONTRIBUTING.md)
doc.
- [x] I have added tests that prove my fix is effective or that my
feature works and increased code coverage.
- [x] I have added all necessary documentation.
(`docs/SourceGeneratedDataTypes.md`, `docs/NodeManagers.md`, generator
readme)
- [x] I have verified that my changes do not introduce (new) build or
analyzer warnings. (`UA.slnx` 0 warnings / 0 errors on net48 and
net10.0)
- [ ] I ran **all** tests locally using the **UA.slnx** solution against
at least .net **framework** and .net **10**, and all passed. The
affected suites were run on net10.0: SourceGeneration Core/Roslyn/Stack,
Types, Core.Encoders, Encoders.Fuzz, Client, Client.ComplexTypes,
PubSub, Core, Server, GDS, Configuration, Di, Robotics, ISA95,
Positioning, OpenUsd, XRegistry. net48 was built; its test legs, and the
post-rebase verification, run in CI.
- [ ] I fixed **all** failing and flaky tests in the CI pipelines and
**all** CodeQL warnings.
- [ ] I have addressed **all** PR feedback received.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
324 lines
16 KiB
C#
324 lines
16 KiB
C#
/* ========================================================================
|
|
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
|
|
*
|
|
* OPC Foundation MIT License 1.00
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person
|
|
* obtaining a copy of this software and associated documentation
|
|
* files (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use,
|
|
* copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following
|
|
* conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* The complete license agreement can be found here:
|
|
* http://opcfoundation.org/License/MIT/1.00/
|
|
* ======================================================================*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using NUnit.Framework;
|
|
|
|
namespace Opc.Ua.SourceGeneration.Generator.Tests
|
|
{
|
|
/// <summary>
|
|
/// Checks that the binary (.bsd) and XML (.xsd) schemas generated for a
|
|
/// ModelDesign describe what the generated Encode methods write.
|
|
/// </summary>
|
|
[TestFixture]
|
|
[Category("Generator")]
|
|
[SetCulture("en-us")]
|
|
[SetUICulture("en-us")]
|
|
[Parallelizable]
|
|
public class SchemaModelTests
|
|
{
|
|
[OneTimeSetUp]
|
|
public void OneTimeSetUp()
|
|
{
|
|
Dictionary<string, string> generated = DataTypeModelTests.Generate(Model);
|
|
m_bsd = generated
|
|
.Single(f => f.Key.EndsWith(".Types.bsd", StringComparison.Ordinal))
|
|
.Value;
|
|
m_xsd = generated
|
|
.Single(f => f.Key.EndsWith(".Types.xsd", StringComparison.Ordinal))
|
|
.Value;
|
|
m_code = string.Concat(generated
|
|
.Where(f => f.Key.EndsWith(".cs", StringComparison.Ordinal))
|
|
.Select(f => f.Value));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D-12: a subtype of the OptionSet structure is encoded as the
|
|
/// structure (Value and ValidBits ByteStrings), not as an integer.
|
|
/// </summary>
|
|
[Test]
|
|
public void StructureOptionSetIsDescribedAsStructuredType()
|
|
{
|
|
string caps = Element(m_bsd, "opc:StructuredType", "Caps");
|
|
Assert.That(caps, Does.Contain("BaseType=\"ua:OptionSet\""));
|
|
Assert.That(caps, Does.Contain("Name=\"Value\" TypeName=\"opc:ByteString\""));
|
|
Assert.That(caps, Does.Contain("Name=\"ValidBits\" TypeName=\"opc:ByteString\""));
|
|
Assert.That(m_bsd, Does.Not.Contain("<opc:EnumeratedType Name=\"Caps\""));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D-12: the size of an integer OptionSet derived from another
|
|
/// OptionSet is the size of the integer at the root, and a declared
|
|
/// zero member is not duplicated by the synthetic "None".
|
|
/// </summary>
|
|
[Test]
|
|
public void IntegerOptionSetLengthAndNone()
|
|
{
|
|
string wide = Element(m_bsd, "opc:EnumeratedType", "Wide");
|
|
Assert.That(wide, Does.Contain("LengthInBits=\"16\""));
|
|
|
|
string withZero = Element(m_bsd, "opc:EnumeratedType", "WithZero");
|
|
Assert.That(
|
|
withZero.Split(["Value=\"0\""], StringSplitOptions.None),
|
|
Has.Length.EqualTo(2));
|
|
Assert.That(withZero, Does.Not.Contain("Name=\"None\""));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D-13: fields the generated code writes as a Variant are described
|
|
/// as a Variant, an array as a counted array.
|
|
/// </summary>
|
|
[Test]
|
|
public void NonArrayValueRanksAreDescribedAsWritten()
|
|
{
|
|
string ranks = Element(m_bsd, "opc:StructuredType", "Ranks");
|
|
Assert.That(ranks, Does.Contain("<opc:Field Name=\"Loose\" TypeName=\"ua:Variant\" />"));
|
|
Assert.That(ranks, Does.Not.Contain("NoOfLoose"));
|
|
Assert.That(ranks, Does.Contain("<opc:Field Name=\"List\" TypeName=\"opc:Int32\" LengthField=\"NoOfList\" />"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D-5: a matrix field is an inline matrix whose value count is the
|
|
/// product of the dimensions, which a DataTypeDictionary cannot
|
|
/// describe: "any Structure with a field or nested field mapped to an
|
|
/// inline matrix ... shall not be included in a DataTypeDictionary"
|
|
/// (OPC 10000-6 5.2.5). It stays in the XML schema, which has the
|
|
/// Matrix type. A field allowing subtypes is an ExtensionObject and
|
|
/// does not nest the matrix.
|
|
/// </summary>
|
|
[Test]
|
|
public void StructuresWithInlineMatricesAreNotInTheBinarySchema()
|
|
{
|
|
Assert.That(m_bsd, Does.Not.Contain("<opc:StructuredType Name=\"Matrices\""));
|
|
Assert.That(m_bsd, Does.Not.Contain("<opc:StructuredType Name=\"HoldsMatrices\""));
|
|
Assert.That(m_bsd, Does.Not.Contain("<opc:StructuredType Name=\"DerivedMatrices\""));
|
|
Assert.That(m_bsd, Does.Contain("<opc:StructuredType Name=\"BaseA\""));
|
|
string refers = Element(m_bsd, "opc:StructuredType", "RefersMatrices");
|
|
Assert.That(refers, Does.Contain("<opc:Field Name=\"Any\" TypeName=\"ua:ExtensionObject\" />"));
|
|
|
|
Assert.That(m_xsd, Does.Contain("<xs:complexType name=\"Matrices\""));
|
|
Assert.That(m_xsd, Does.Contain("<xs:complexType name=\"HoldsMatrices\""));
|
|
|
|
// No DataTypeDescription in the binary dictionary node either,
|
|
// the XML dictionary keeps it.
|
|
Assert.That(m_code, Does.Not.Contain("BinarySchema_Matrices"));
|
|
Assert.That(m_code, Does.Not.Contain("BinarySchema_HoldsMatrices"));
|
|
Assert.That(m_code, Does.Contain("BinarySchema_RefersMatrices"));
|
|
Assert.That(m_code, Does.Contain("XmlSchema_Matrices"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D-14: the XmlEncoder writes an EncodingMask element first for a
|
|
/// structure with optional fields; a derived type introducing
|
|
/// optional fields writes it ahead of the base fields and is
|
|
/// flattened; a union may carry no member at all.
|
|
/// </summary>
|
|
[Test]
|
|
public void XmlSchemaDescribesEncodingMaskAndEmptyUnion()
|
|
{
|
|
string opt = Element(m_xsd, "xs:complexType", "Opt");
|
|
Assert.That(
|
|
opt.IndexOf("name=\"EncodingMask\"", StringComparison.Ordinal),
|
|
Is.GreaterThan(0).And.LessThan(opt.IndexOf("name=\"Note\"", StringComparison.Ordinal)));
|
|
|
|
// OPC 10000-6 5.3.6: the mask element is mandatory and typed as in
|
|
// the example of the clause.
|
|
Assert.That(opt, Does.Contain("<xs:element name=\"EncodingMask\" type=\"xs:unsignedLong\" />"));
|
|
|
|
string derived = Element(m_xsd, "xs:complexType", "OptDerived");
|
|
Assert.That(derived, Does.Not.Contain("xs:extension"));
|
|
int mask = derived.IndexOf("name=\"EncodingMask\"", StringComparison.Ordinal);
|
|
int a = derived.IndexOf("name=\"A\"", StringComparison.Ordinal);
|
|
int b = derived.IndexOf("name=\"B\"", StringComparison.Ordinal);
|
|
Assert.That(mask, Is.GreaterThan(0));
|
|
Assert.That(a, Is.GreaterThan(mask));
|
|
Assert.That(b, Is.GreaterThan(a));
|
|
|
|
// The mask is written once, by the type that introduced it.
|
|
string leaf = Element(m_xsd, "xs:complexType", "OptLeaf");
|
|
Assert.That(leaf, Does.Contain("xs:extension"));
|
|
Assert.That(leaf, Does.Not.Contain("EncodingMask"));
|
|
|
|
string choice = Element(m_xsd, "xs:complexType", "Choice");
|
|
Assert.That(choice, Does.Contain("<xs:choice minOccurs=\"0\">"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D5: only a Structure field allowing subtypes is an ExtensionObject
|
|
/// (OPC 10000-6 5.1.7); an abstract non-structure field allowing
|
|
/// subtypes is written as a Variant and described as one.
|
|
/// </summary>
|
|
[Test]
|
|
public void SubtypedNonStructureFieldsAreVariants()
|
|
{
|
|
string subtyped = Element(m_bsd, "opc:StructuredType", "Subtyped");
|
|
Assert.That(subtyped, Does.Contain("<opc:Field Name=\"Num\" TypeName=\"ua:Variant\" />"));
|
|
Assert.That(subtyped, Does.Contain("<opc:Field Name=\"Any\" TypeName=\"ua:Variant\" />"));
|
|
Assert.That(subtyped, Does.Contain("<opc:Field Name=\"Nested\" TypeName=\"ua:ExtensionObject\" />"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// D5: an EnumeratedValue Value is an xs:int (OPC 10000-5 C.2.7), so
|
|
/// the mask of bit 31 or above is not written as a value.
|
|
/// </summary>
|
|
[Test]
|
|
public void OptionSetMasksBeyondXsIntAreLeftOut()
|
|
{
|
|
string bits = Element(m_bsd, "opc:EnumeratedType", "HighBits");
|
|
Assert.That(bits, Does.Contain("<opc:EnumeratedValue Name=\"Low\" Value=\"1\" />"));
|
|
Assert.That(bits, Does.Not.Contain("Value=\"2147483648\""));
|
|
Assert.That(bits, Does.Not.Contain("Name=\"Top\""));
|
|
Assert.That(bits, Does.Contain("<!-- Top = 2147483648"));
|
|
}
|
|
|
|
private static string Element(string schema, string element, string name)
|
|
{
|
|
string start = "<" + element + " Name=\"" + name + "\"";
|
|
if (element.StartsWith("xs:", StringComparison.Ordinal))
|
|
{
|
|
start = "<" + element + " name=\"" + name + "\"";
|
|
}
|
|
int begin = schema.IndexOf(start, StringComparison.Ordinal);
|
|
Assert.That(begin, Is.GreaterThanOrEqualTo(0), start + " not found");
|
|
int end = schema.IndexOf("</" + element + ">", begin, StringComparison.Ordinal);
|
|
return schema.Substring(begin, end - begin);
|
|
}
|
|
|
|
private const string Model =
|
|
"""
|
|
<?xml version="1.0" encoding="utf-8" ?>
|
|
<opc:ModelDesign
|
|
xmlns:opc="http://opcfoundation.org/UA/ModelDesign.xsd"
|
|
xmlns:ua="http://opcfoundation.org/UA/"
|
|
xmlns="http://test.org/UA/Schema/"
|
|
TargetNamespace="http://test.org/UA/Schema/">
|
|
<opc:Namespaces>
|
|
<opc:Namespace Name="Schema" Prefix="Test.Schema">http://test.org/UA/Schema/</opc:Namespace>
|
|
<opc:Namespace Name="OpcUa" Prefix="Opc.Ua" XmlNamespace="http://opcfoundation.org/UA/2008/02/Types.xsd">http://opcfoundation.org/UA/</opc:Namespace>
|
|
</opc:Namespaces>
|
|
<opc:DataType SymbolicName="Caps" BaseType="ua:OptionSet" IsOptionSet="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="Read" Identifier="0" />
|
|
<opc:Field Name="Write" Identifier="1" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="BaseFlags" BaseType="ua:UInt16" IsOptionSet="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="X" BitMask="0001" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Wide" BaseType="BaseFlags" IsOptionSet="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="Y" BitMask="0002" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="WithZero" BaseType="ua:UInt32" IsOptionSet="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="Nothing" Identifier="0" />
|
|
<opc:Field Name="One" BitMask="0001" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="HighBits" BaseType="ua:UInt32" IsOptionSet="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="Low" BitMask="0001" />
|
|
<opc:Field Name="Top" BitMask="80000000" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Subtyped" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Num" DataType="ua:Number" AllowSubTypes="true" />
|
|
<opc:Field Name="Any" DataType="ua:BaseDataType" AllowSubTypes="true" />
|
|
<opc:Field Name="Nested" DataType="BaseA" AllowSubTypes="true" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="BaseA" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="A" DataType="ua:Int32" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Ranks" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Loose" DataType="ua:Double" ValueRank="ScalarOrArray" />
|
|
<opc:Field Name="List" DataType="ua:Int32" ValueRank="Array" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Matrices" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Grid" DataType="ua:Double" ValueRank="OneOrMoreDimensions" ArrayDimensions="3,3" />
|
|
<opc:Field Name="Cells" DataType="BaseA" ValueRank="OneOrMoreDimensions" ArrayDimensions="0,0" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="HoldsMatrices" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Inner" DataType="Matrices" ValueRank="Array" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="DerivedMatrices" BaseType="Matrices">
|
|
<opc:Fields>
|
|
<opc:Field Name="Extra" DataType="ua:Int32" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="RefersMatrices" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Any" DataType="Matrices" AllowSubTypes="true" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Opt" BaseType="ua:Structure">
|
|
<opc:Fields>
|
|
<opc:Field Name="Level" DataType="ua:Int32" />
|
|
<opc:Field Name="Note" DataType="ua:String" IsOptional="true" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="OptDerived" BaseType="BaseA">
|
|
<opc:Fields>
|
|
<opc:Field Name="B" DataType="ua:Int32" IsOptional="true" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="OptLeaf" BaseType="OptDerived">
|
|
<opc:Fields>
|
|
<opc:Field Name="C" DataType="ua:Int32" IsOptional="true" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
<opc:DataType SymbolicName="Choice" BaseType="ua:Union" IsUnion="true">
|
|
<opc:Fields>
|
|
<opc:Field Name="X" DataType="ua:Int32" />
|
|
<opc:Field Name="Y" DataType="ua:String" />
|
|
</opc:Fields>
|
|
</opc:DataType>
|
|
</opc:ModelDesign>
|
|
""";
|
|
|
|
private string m_bsd;
|
|
private string m_xsd;
|
|
private string m_code;
|
|
}
|
|
}
|