public void CheckNodeInfoListAccordingToConnectionStatus()
        {
            var connection     = new TestConnection();
            var nodeinfogetter = new TestNodeInfoGetter();
            var model          = new Jupiter.Models.NodeInfoDataGridModel(connection, nodeinfogetter);
            var reference      = new OPCUAReference(null, null, null);

            model.Update(reference);
            var expectedNodeInfoList0 = new ObservableCollection <NodeInfo>()
            {
                new NodeInfo()
                {
                    Name = "Var1", Value = "1234"
                },
                new NodeInfo()
                {
                    Name = "Var2", Value = "1234567890"
                },
                new NodeInfo()
                {
                    Name = "Var3", Value = "-1234.5678"
                },
                new NodeInfo()
                {
                    Name = "Var4", Value = "abcdefghij"
                },
            };

            Assert.AreEqual(model.NodeInfoList.Count, 4);
            for (int i = 0; i < 4; i++)
            {
                var actual = model.NodeInfoList[i];
                var expect = expectedNodeInfoList0[i];
                Assert.AreEqual(actual.Name, expect.Name);
                Assert.AreEqual(actual.Value, expect.Value);
            }
            connection.Connected = true;
            connection.Connected = false;
            Assert.AreEqual(model.NodeInfoList.Count, 0);
        }
        public void CheckNodeInfoListAfterExecutingUpdate()
        {
            var connection     = new TestConnection();
            var nodeinfogetter = new TestNodeInfoGetter();
            var model          = new Jupiter.Models.NodeInfoDataGridModel(connection, nodeinfogetter);
            var reference      = new OPCUAReference(null, null, null);

            model.Update(reference);
            var expectedNodeInfoList0 = new ObservableCollection <NodeInfo>()
            {
                new NodeInfo()
                {
                    Name = "Var1", Value = "1234"
                },
                new NodeInfo()
                {
                    Name = "Var2", Value = "1234567890"
                },
                new NodeInfo()
                {
                    Name = "Var3", Value = "-1234.5678"
                },
                new NodeInfo()
                {
                    Name = "Var4", Value = "abcdefghij"
                },
            };

            Assert.AreEqual(model.NodeInfoList.Count, 4);
            for (int i = 0; i < 4; i++)
            {
                var actual = model.NodeInfoList[i];
                var expect = expectedNodeInfoList0[i];
                Assert.AreEqual(actual.Name, expect.Name);
                Assert.AreEqual(actual.Value, expect.Value);
            }

            reference.NodeId = new ExpandedNodeId("1");
            model.Update(reference);
            var expectedNodeInfoList1 = new ObservableCollection <NodeInfo>()
            {
                new NodeInfo()
                {
                    Name = "変数1", Value = "1234"
                },
                new NodeInfo()
                {
                    Name = "変数2", Value = "1234567890"
                },
                new NodeInfo()
                {
                    Name = "変数3", Value = "-1234.5678"
                },
                new NodeInfo()
                {
                    Name = "変数4", Value = "abcdefghij"
                },
                new NodeInfo()
                {
                    Name = "変数5", Value = "あいうえお"
                },
            };

            Assert.AreEqual(model.NodeInfoList.Count, 5);
            for (int i = 0; i < 4; i++)
            {
                var actual = model.NodeInfoList[i];
                var expect = expectedNodeInfoList1[i];
                Assert.AreEqual(actual.Name, expect.Name);
                Assert.AreEqual(actual.Value, expect.Value);
            }
        }
        private void ReadCommandBase(string endpoint, List <TestPattern> testPatterns)
        {
            var variables = _readCommandBase_CreateTestVariables(testPatterns);

            var application = _readCommandBase_CreateApplication(endpoint);

            using (var s = TestServer.TestServer.StartServer(application, variables))
            {
                _readCommandBase_ServerInit(s, testPatterns);

                var ea  = new Prism.Events.EventAggregator();
                var msg = "";

                ea.GetEvent <Jupiter.Events.ErrorNotificationEvent>()
                .Subscribe(x => msg = x.Message);

                var c          = new Client(ea);
                var references = new OPCUAReference(c, null, ea);
                var ota        = new Jupiter.Models.OneTimeAccessModel(c, c);
                ota.EventAggregator = ea;
                var nodegrid = new Jupiter.Models.NodeInfoDataGridModel(c, c);
                var nodetree = new Jupiter.Models.NodeTreeModel(c, references, null, ota);
                nodetree.EventAggregator = ea;

                c.EventAggregator
                .GetEvent <Jupiter.Events.NowLoadingEvent>()
                .Subscribe((x) =>
                {
                    var first = x.ServerList.First();

                    x.Client.BrowseSecurityList(first);

                    for (int i = 0; i < first.Endpoints.Count; i++)
                    {
                        if (first.Endpoints[i].SecurityMode.ToString().EndsWith("None"))
                        {
                            Console.WriteLine(first.Endpoints[i].SecurityMode);
                            x.SelectedIndex       = i;
                            x.SelectedServerIndex = 0;
                            x.Result = true;
                            break;
                        }
                    }
                });

                c.CreateSession(endpoint).Wait();
                foreach (OPCUAReference ch in references.Children)
                {
                    if (ch.DisplayName != "TestData")
                    {
                        continue;
                    }

                    nodetree.UpdateVariableNodeListCommand.Execute(ch);
                    foreach (VariableInfo vn in nodetree.VariableNodes)
                    {
                        nodetree.AddToReadWriteCommand.Execute(new List <VariableInfo>()
                        {
                            vn
                        });
                    }
                }
                ;
                ota.ReadCommand.Execute(null);
                Assert.AreEqual(msg, "");
                Assert.AreEqual(ota.OneTimeAccessItems.Count, testPatterns.Count);
                for (int i = 0; i < testPatterns.Count; i++)
                {
                    var got  = ((VariableInfo)ota.OneTimeAccessItems[i]).Value.ToString();
                    var want = testPatterns[i].Value.ToString();
                    Assert.AreEqual(got, want);
                }
            }
        }