Opc.Ua.ServerTest.BrowseTest.VerifyTypeDefinitions C# (CSharp) Method

VerifyTypeDefinitions() private method

Reads the attribute values in order to compare them to the returned results.
private VerifyTypeDefinitions ( Node node, BrowseDescription description, ReferenceDescriptionCollection references ) : bool
node Node
description BrowseDescription
references ReferenceDescriptionCollection
return bool
        private bool VerifyTypeDefinitions(
            Node node, 
            BrowseDescription description, 
            ReferenceDescriptionCollection references)
        {
            // check if nothing to do.
            if (references.Count == 0)
            {
                return true;
            }

            bool success = true;

            BrowseDescriptionCollection nodesToBrowse = new BrowseDescriptionCollection();
            
            for (int ii = 0; ii < references.Count; ii++)
            {
                ReferenceDescription reference = references[ii];

                if ((description.ResultMask & (uint)BrowseResultMask.TypeDefinition) == 0)
                {
                    if (!NodeId.IsNull(reference.TypeDefinition))
                    {
                        success = false;

                        Log(
                            "Unexpected TypeDefinition returned for Node '{0}'. NodeId = {1}, TargetId = {2}, TypeDefinition = {3}",
                            node, 
                            node.NodeId, 
                            reference.NodeId,
                            reference.TypeDefinition);
                    }

                    continue;
                }

                // ignore invalid or external references.
                if (reference == null || reference.NodeId == null || reference.NodeId.IsAbsolute)
                {
                    continue;
                }

                BrowseDescription nodeToBrowse = new BrowseDescription();
                
                nodeToBrowse.NodeId = (NodeId)reference.NodeId;
                nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
                nodeToBrowse.IncludeSubtypes = false;
                nodeToBrowse.NodeClassMask = 0;
                nodeToBrowse.ReferenceTypeId = ReferenceTypeIds.HasTypeDefinition;
                nodeToBrowse.ResultMask = (uint)BrowseResultMask.None;
                nodeToBrowse.Handle = references[ii];
                
                nodesToBrowse.Add(nodeToBrowse);
            }

            // nothing more to do if no type definitions requested.
            if ((description.ResultMask & (uint)BrowseResultMask.TypeDefinition) == 0)
            {
                return success;
            }

            // browse.
            BrowseResultCollection results;
            DiagnosticInfoCollection diagnosticInfos;
            
            RequestHeader requestHeader = new RequestHeader();
            requestHeader.ReturnDiagnostics = 0;

            Session.Browse(
                null,
                m_view,
                0,
                nodesToBrowse,
                out results,
                out diagnosticInfos);
            
            ClientBase.ValidateResponse(results, nodesToBrowse);
            ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToBrowse);
            
            // check diagnostics.
            if (diagnosticInfos != null && diagnosticInfos.Count > 0)
            {
                Log("Returned non-empty DiagnosticInfos array when Browsing TypeDefinition while Browsing Node '{0}'. NodeId = {1}", node, node.NodeId);
                return false;
            }

            bool error = false;

            for (int ii = 0; ii < nodesToBrowse.Count; ii++)
            {
                BrowseResult result = results[ii];
                
                if (StatusCode.IsBad(result.StatusCode))
                {
                    error = true;

                    Log(
                        "Browse TypeDefinition Failed for Node '{0}'. NodeId = {1}, TargetId = {2}, Status = {3}",
                        node, 
                        node.NodeId, 
                        nodesToBrowse[ii].NodeId,
                        results[0].StatusCode);
                    
                    continue;
                }

                ReferenceDescription reference = (ReferenceDescription)nodesToBrowse[ii].Handle;

                if (result.References.Count == 0)
                {
                    if (!NodeId.IsNull(reference.TypeDefinition))
                    {
                        error = true;

                        Log(
                            "Unexpected TypeDefinition returned for Node '{0}'. NodeId = {1}, TargetId = {2}, TypeDefinition = {3}",
                            node, 
                            node.NodeId, 
                            nodesToBrowse[ii].NodeId,
                            reference.TypeDefinition);
                    
                        continue;
                    }
                }
                else
                {
                    if (result.References.Count != 1)
                    {
                        error = true;

                        Log(
                            "Too many TypeDefinitions returned for Node '{0}'. NodeId = {1}, TargetId = {2}, Count = {3}",
                            node, 
                            node.NodeId, 
                            nodesToBrowse[ii].NodeId,
                            result.References.Count);
                    
                        continue;
                    }

                    if (result.References[0].NodeId != reference.TypeDefinition)
                    {
                        error = true;

                        Log(
                            "Incorrect TypeDefinition returned for Node '{0}'. NodeId = {1}, TargetId = {2}, Expected = {3}, Actual = {4}",
                            node, 
                            node.NodeId, 
                            nodesToBrowse[ii].NodeId,
                            result.References[0].NodeId,
                            reference.TypeDefinition);
                    
                        continue;
                    }
                }
            }

            return !error;
        }
        #endregion