Esempio n. 1
0
        public void InstanceSubScopeRemovedFromReferenceEquipment()
        {
            //Arrange
            TECTemplates templates = new TECTemplates();
            TemplateSynchronizer <TECEquipment> equipSynchronizer = templates.EquipmentSynchronizer;
            TemplateSynchronizer <TECSubScope>  ssSynchronizer    = templates.SubScopeSynchronizer;

            TECEquipment templateEquip = new TECEquipment();

            templates.Templates.EquipmentTemplates.Add(templateEquip);

            TECSubScope ss = new TECSubScope();

            templateEquip.SubScope.Add(ss);

            TECEquipment refEqiup = equipSynchronizer.NewItem(templateEquip);
            TECSubScope  refSS    = refEqiup.SubScope[0];

            //Act
            refEqiup.SubScope.Remove(refSS);

            //Assert
            Assert.IsTrue(templateEquip.SubScope.Count == 0, "SubScope not removed properly from Equipment template.");

            Assert.IsFalse(ssSynchronizer.Contains(ss), "SubScope was not removed properly from synchronizer.");
            Assert.IsFalse(ssSynchronizer.Contains(refSS), "Reference SubScope was not removed properly from synchronizer.");
        }
        public void CanConnectToNetworkTest1()
        {
            TECProtocol firstProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol secondProtocol = new TECProtocol(new List <TECConnectionType>());
            TECProtocol thirdProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol fourthProtocol = new TECProtocol(new List <TECConnectionType>());

            TECDevice compatibleDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                secondProtocol, firstProtocol, fourthProtocol
            }, new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(firstProtocol));
            type.IO.Add(new TECIO(secondProtocol));
            type.IO.Add(new TECIO(thirdProtocol));

            TECProvidedController controller = new TECProvidedController(type);
            TECNetworkConnection  connection = controller.AddNetworkConnection(thirdProtocol);

            Assert.IsFalse(subScope.CanConnectToNetwork(connection));
        }
        private void addExecute()
        {
            for (int x = 0; x < Quantity; x++)
            {
                TECSubScope subScope = null;
                if (underlyingTemplate != null)
                {
                    subScope = AsReference ? templates.SubScopeSynchronizer.NewItem(underlyingTemplate) : new TECSubScope(underlyingTemplate);
                    subScope.CopyPropertiesFromScope(ToAdd);
                    foreach (IEndDevice device in ToAdd.Devices.Where(item => !originalDevices.Contains(item)))
                    {
                        subScope.AddDevice(device);
                    }
                    foreach (TECPoint point in ToAdd.Points.Where(item => !originalPoints.Contains(item)))
                    {
                        subScope.AddPoint(point);
                    }
                }
                else
                {
                    subScope = new TECSubScope(ToAdd);
                }

                add(subScope);
                if (ConnectVM != null && ConnectVM.Connect)
                {
                    ConnectVM.ExecuteConnection(subScope);
                }
                Added?.Invoke(subScope);
            }
        }
        public void AddDeviceToConnectedNetwork()
        {
            TECControllerType type     = new TECControllerType(new TECManufacturer());
            TECProtocol       protocol = new TECProtocol(new List <TECConnectionType>());

            type.IO.Add(new TECIO(protocol));
            TECProvidedController controller = new TECProvidedController(type);

            TECDevice device = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol> {
                protocol
            }, new TECManufacturer());

            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(device);

            controller.Connect(subScope, protocol);

            TECDevice otherDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol> {
                protocol
            }, new TECManufacturer());

            subScope.AddDevice(otherDevice);
            Assert.IsTrue(subScope.Devices.Contains(otherDevice));

            TECProtocol otherProtocol = new TECProtocol(new List <TECConnectionType>());
            TECDevice   nextDevice    = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol> {
                otherProtocol
            }, new TECManufacturer());

            subScope.AddDevice(nextDevice);
            Assert.IsFalse(subScope.Devices.Contains(nextDevice));
        }
        public void AvailableProtocols1()
        {
            TECConnectionType type1 = new TECConnectionType();
            TECConnectionType type2 = new TECConnectionType();

            TECProtocol prot1 = new TECProtocol(new List <TECConnectionType>());
            TECProtocol prot2 = new TECProtocol(new List <TECConnectionType>());
            TECProtocol prot3 = new TECProtocol(new List <TECConnectionType>());

            TECDevice dev1 = new TECDevice(new List <TECConnectionType>(),
                                           new List <TECProtocol> {
                prot1, prot2
            }, new TECManufacturer());
            TECDevice dev2 = new TECDevice(new List <TECConnectionType> {
                type2
            },
                                           new List <TECProtocol> {
                prot1, prot3
            }, new TECManufacturer());

            TECSubScope ss        = new TECSubScope();
            bool        dev1Added = ss.AddDevice(dev1);
            bool        dev2Added = ss.AddDevice(dev2);

            Assert.IsTrue(dev1Added);
            Assert.IsTrue(dev2Added);

            Assert.IsFalse(ss.AvailableProtocols.Any(prot => { return(prot is TECHardwiredProtocol); }));
            Assert.IsTrue(ss.AvailableProtocols.Contains(prot1));
            Assert.IsFalse(ss.AvailableProtocols.Contains(prot2));
            Assert.IsFalse(ss.AvailableProtocols.Contains(prot3));
            Assert.AreEqual(1, ss.AvailableProtocols.Count);
        }
        public void RemoveNetworkConnectionTest()
        {
            TECProtocol firstProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol secondProtocol = new TECProtocol(new List <TECConnectionType>());
            TECProtocol thirdProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol fourthProtocol = new TECProtocol(new List <TECConnectionType>());

            TECDevice compatibleDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                secondProtocol, firstProtocol, fourthProtocol
            }, new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(firstProtocol));
            type.IO.Add(new TECIO(secondProtocol));
            type.IO.Add(new TECIO(thirdProtocol));

            TECProvidedController controller = new TECProvidedController(type);

            TECNetworkConnection connection = controller.Connect(subScope, firstProtocol) as TECNetworkConnection;

            controller.RemoveNetworkConnection(connection);

            Assert.IsFalse(connection.Children.Contains(subScope));
            Assert.IsFalse(controller.ChildrenConnections.Contains(connection));
            Assert.IsNull((subScope as IConnectable).GetParentConnection());
        }
        public void AddPointToConnectedNetwork()
        {
            TECControllerType type     = new TECControllerType(new TECManufacturer());
            TECProtocol       protocol = new TECProtocol(new List <TECConnectionType>());

            type.IO.Add(new TECIO(IOType.AI));
            type.IO.Add(new TECIO(protocol));
            TECProvidedController controller = new TECProvidedController(type);

            TECDevice device = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol> {
                protocol
            }, new TECManufacturer());

            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(device);

            controller.Connect(subScope, protocol);

            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.AddPoint(point);

            Assert.IsTrue(subScope.Points.Contains(point));
            Assert.IsTrue(controller.AvailableIO.IONumber(IOType.AI) == 1);

            TECPoint otherPoint = new TECPoint();

            otherPoint.Type = IOType.AI;

            subScope.AddPoint(otherPoint);
            Assert.IsTrue(subScope.Points.Contains(otherPoint));
            Assert.IsTrue(controller.AvailableIO.IONumber(IOType.AI) == 1);
        }
Esempio n. 8
0
        public void CanConnectTest4()
        {
            TECProtocol firstProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol secondProtocol = new TECProtocol(new List <TECConnectionType>());
            TECProtocol thirdProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol fourthProtocol = new TECProtocol(new List <TECConnectionType>());

            TECDevice compatibleDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                secondProtocol, firstProtocol, fourthProtocol
            }, new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);

            TECControllerType type   = new TECControllerType(new TECManufacturer());
            TECIOModule       module = new TECIOModule(new TECManufacturer());

            module.IO.Add(new TECIO(firstProtocol));
            module.IO.Add(new TECIO(secondProtocol));
            module.IO.Add(new TECIO(thirdProtocol));
            type.IOModules.Add(module);

            TECProvidedController controller = new TECProvidedController(type);

            Assert.IsTrue(controller.CanConnect(subScope, firstProtocol));
            Assert.IsTrue(controller.CanConnect(subScope, secondProtocol));
            Assert.IsFalse(controller.CanConnect(subScope, fourthProtocol));
        }
Esempio n. 9
0
        public void ConnectTest3()
        {
            TECConnectionType connectionType   = new TECConnectionType();
            TECDevice         compatibleDevice = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);
            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.Points.Add(point);

            TECControllerType type   = new TECControllerType(new TECManufacturer());
            TECIOModule       module = new TECIOModule(new TECManufacturer());

            module.IO.Add(new TECIO(IOType.AO));
            type.IOModules.Add(module);

            TECProvidedController  controller = new TECProvidedController(type);
            TECHardwiredConnection connection = controller.Connect(subScope, subScope.HardwiredProtocol()) as TECHardwiredConnection;

            Assert.IsNull(connection);
        }
        private string getTemplateText(TECObject item)
        {
            TECTemplates templates = ScopeManager as TECTemplates;

            if (templates.IsTemplateObject(item))
            {
                string parentString = "";
                if (item is TECSubScope subScope)
                {
                    TECSubScope parent = templates.SubScopeSynchronizer.GetParent(subScope);
                    if (item != parent && parent != null)
                    {
                        parentString = String.Format(" of {0}",
                                                     parent.Name);
                    }
                }
                else if (item is TECEquipment equipment)
                {
                    TECEquipment parent = templates.EquipmentSynchronizer.GetParent(equipment);
                    if (item != parent && parent != null)
                    {
                        parentString = String.Format(" of {0}",
                                                     parent.Name);
                    }
                }

                return(String.Format("Reference{0}",
                                     parentString));
            }
            return("Instance Template");
        }
Esempio n. 11
0
        public void CanChangeTypeTest1()
        {
            TECControllerType cType    = new TECControllerType(new TECManufacturer());
            TECProtocol       protocol = new TECProtocol(new List <TECConnectionType>());

            cType.IO.Add(new TECIO(protocol));
            cType.IO.Add(new TECIO(IOType.AI));

            TECControllerType otherCType = new TECControllerType(new TECManufacturer());

            TECProvidedController controller = new TECProvidedController(cType);

            TECSubScope ss1 = new TECSubScope();
            TECSubScope ss2 = new TECSubScope();

            TECDevice proDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                protocol
            }, new TECManufacturer());
            TECDevice hardDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>(), new TECManufacturer());

            ss1.Devices.Add(proDevice);
            ss2.Devices.Add(hardDevice);
            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            ss2.AddPoint(point);

            controller.Connect(ss1, protocol);
            controller.Connect(ss2, ss2.HardwiredProtocol());

            Assert.IsFalse(controller.CanChangeType(otherCType));
        }
        public void Undo_Template_Equipment_SubScope()
        {
            //Arrange
            var Template  = ModelCreation.TestTemplates(rand);
            var equipment = Template.Templates.EquipmentTemplates[0];
            ObservableCollection <TECSubScope> expected = new ObservableCollection <TECSubScope>();

            foreach (TECSubScope item in equipment.SubScope)
            {
                expected.Add(item);
            }
            TECSubScope edit = new TECSubScope();

            //Act
            ChangeWatcher watcher = new ChangeWatcher(Template); DoStacker testStack = new DoStacker(watcher);

            equipment.SubScope.Add(edit);
            Assert.AreEqual(1, testStack.UndoCount(), "Not added to undo stack");
            testStack.Undo();

            //assert
            var actual = equipment.SubScope;

            Assert.AreEqual(expected.Count, actual.Count, "Not Undone");
        }
        public void SaveNew_Templates_Equipment()
        {
            //Arrange
            TECSubScope     actualEquipSubScope = actualEquipment.SubScope.First(item => item.Devices.Count > 0 && item.Points.Count > 0);
            TECDevice       actualChildDevice   = actualEquipSubScope.Devices[0] as TECDevice;
            TECPoint        actualEquipPoint    = actualEquipSubScope.Points[0];
            TECManufacturer actualChildMan      = actualChildDevice.Manufacturer;

            TECSubScope     expectedEquipSubScope = expectedEquipment.SubScope.First(item => item.Guid == actualEquipSubScope.Guid);
            TECDevice       expectedChildDevice   = expectedEquipSubScope.Devices[0] as TECDevice;
            TECPoint        expectedEquipPoint    = expectedEquipSubScope.Points[0];
            TECManufacturer expectedChildMan      = expectedChildDevice.Manufacturer;

            //Assert
            Assert.AreEqual(expectedEquipment.Name, actualEquipment.Name);
            Assert.AreEqual(expectedEquipment.Description, actualEquipment.Description);
            Assert.AreEqual(expectedEquipment.Tags[0].Label, actualEquipment.Tags[0].Label);

            Assert.AreEqual(expectedEquipSubScope.Name, actualEquipSubScope.Name);
            Assert.AreEqual(expectedEquipSubScope.Description, actualEquipSubScope.Description);
            Assert.AreEqual(expectedEquipSubScope.Tags[0].Label, actualEquipSubScope.Tags[0].Label);

            Assert.AreEqual(expectedChildDevice.Name, actualChildDevice.Name);
            Assert.AreEqual(expectedChildDevice.Description, actualChildDevice.Description);
            Assert.AreEqual(expectedChildDevice.Cost, actualChildDevice.Cost, DELTA);

            Assert.AreEqual(expectedEquipPoint.Label, actualEquipPoint.Label);
            Assert.AreEqual(expectedEquipPoint.Quantity, actualEquipPoint.Quantity);
            Assert.AreEqual(expectedEquipPoint.Type, actualEquipPoint.Type);

            Assert.AreEqual(expectedChildMan.Label, actualChildMan.Label);
            Assert.AreEqual(expectedChildMan.Multiplier, actualChildMan.Multiplier, DELTA);
        }
Esempio n. 14
0
        public void GetConnectablesTest()
        {
            TECSystem    system    = new TECSystem();
            TECEquipment equipment = new TECEquipment();

            system.Equipment.Add(equipment);
            TECSubScope first  = new TECSubScope();
            TECSubScope second = new TECSubScope();

            equipment.SubScope.Add(first);
            equipment.SubScope.Add(second);
            TECProvidedController controller = new TECProvidedController(new TECControllerType(new TECManufacturer()));

            system.AddController(controller);

            var connectables = ConnectionHelper.GetConnectables(system, obj => true);

            Assert.IsTrue(connectables.Count == 3);
            Assert.IsTrue(connectables.Contains(first));
            Assert.IsTrue(connectables.Contains(second));
            Assert.IsTrue(connectables.Contains(controller));

            connectables = ConnectionHelper.GetConnectables(system, obj => obj is TECSubScope);

            Assert.IsTrue(connectables.Count == 2);
            Assert.IsTrue(connectables.Contains(first));
            Assert.IsTrue(connectables.Contains(second));
        }
        public void ConnectTest2()
        {
            TECConnectionType connectionType   = new TECConnectionType();
            TECDevice         compatibleDevice = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);
            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.Points.Add(point);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(IOType.AI));

            TECProvidedController controller = new TECProvidedController(type);

            TECHardwiredConnection connection = controller.Connect(subScope, subScope.HardwiredProtocol()) as TECHardwiredConnection;

            Assert.IsTrue(connection.Child == subScope);
            Assert.IsTrue(controller.ChildrenConnections.Contains(connection));
            Assert.IsTrue((subScope as IConnectable).GetParentConnection() == connection);
            Assert.IsTrue(connection.Protocol is TECHardwiredProtocol);
        }
Esempio n. 16
0
        public void AddValve()
        {
            //Arrange
            TECValve valve = ModelCreation.TestValve(bid.Catalogs, rand);

            valve.AssignRandomScopeProperties(bid.Catalogs, rand);

            TECTypical typical = new TECTypical();

            bid.Systems.Add(typical);

            TECEquipment typEquip = new TECEquipment();

            typical.Equipment.Add(typEquip);

            TECSubScope typSS = new TECSubScope();

            typEquip.SubScope.Add(typSS);

            typical.AddInstance();

            MaterialSummaryVM matVM = new MaterialSummaryVM(bid, cw);

            //Act
            typSS.Devices.Add(valve);

            //Assert
            AssertMaterialVMMatchesCostBatch(matVM, valve.CostBatch);
        }
        public void DiconnectTest1()
        {
            TECConnectionType connectionType   = new TECConnectionType();
            TECDevice         compatibleDevice = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);
            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.Points.Add(point);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(IOType.AI));

            TECProvidedController controller = new TECProvidedController(type);

            TECHardwiredConnection connection = controller.Connect(subScope, subScope.AvailableProtocols.First(x => x is TECHardwiredProtocol)) as TECHardwiredConnection;

            controller.Disconnect(subScope);

            Assert.IsFalse(controller.ChildrenConnections.Contains(connection));
            Assert.IsNull((subScope as IConnectable).GetParentConnection());
        }
Esempio n. 18
0
        public void RemoveDevice()
        {
            //Arrange
            TECTypical typical = new TECTypical();

            bid.Systems.Add(typical);

            TECEquipment typEquip = new TECEquipment();

            typical.Equipment.Add(typEquip);

            TECSubScope typSS = new TECSubScope();

            typEquip.SubScope.Add(typSS);

            TECDevice device = bid.Catalogs.Devices[0];

            device.AssignRandomScopeProperties(bid.Catalogs, rand);
            typSS.Devices.Add(device);

            typical.AddInstance();

            MaterialSummaryVM matVM = new MaterialSummaryVM(bid, cw);

            CostBatch initial = MatVMToCostBatch(matVM);

            //Act
            typSS.Devices.Remove(device);

            //Assert
            AssertMaterialVMMatchesCostBatch(matVM, initial - device.CostBatch);
        }
Esempio n. 19
0
        public void UnionizeScopeCollectionTest()
        {
            TECSubScope scope1         = new TECSubScope();
            TECSubScope scope2         = new TECSubScope();
            TECSubScope scopeOverwrite = new TECSubScope(scope2.Guid);
            TECSubScope scope3         = new TECSubScope();

            List <ITECScope> first = new List <ITECScope>()
            {
                scope1,
                scopeOverwrite
            };

            List <ITECScope> second = new List <ITECScope>()
            {
                scope2,
                scope3
            };

            CommonUtilities.UnionizeScopeCollection(first, second);

            Assert.IsTrue(first.Contains(scope3));
            Assert.IsTrue(first.Contains(scope2));
            Assert.IsFalse(first.Contains(scopeOverwrite));
        }
Esempio n. 20
0
        public void RemoveValve()
        {
            //Arrange
            bid.Catalogs.Add(ModelCreation.TestValve(bid.Catalogs, rand));
            ChangeWatcher cw = new ChangeWatcher(bid);

            TECTypical typical = new TECTypical();

            bid.Systems.Add(typical);

            TECEquipment typEquip = new TECEquipment();

            typical.Equipment.Add(typEquip);

            TECSubScope typSS = new TECSubScope();

            typEquip.SubScope.Add(typSS);

            TECValve valve = bid.Catalogs.Valves[0];

            valve.AssignRandomScopeProperties(bid.Catalogs, rand);
            typSS.Devices.Add(valve);

            typical.AddInstance();

            MaterialSummaryVM matVM = new MaterialSummaryVM(bid, cw);

            CostBatch initial = MatVMToCostBatch(matVM);

            //Act
            typSS.Devices.Remove(valve);

            //Assert
            AssertMaterialVMMatchesCostBatch(matVM, initial - valve.CostBatch);
        }
        public void AddDeviceToConnectedHardwired()
        {
            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(IOType.AI));
            TECProvidedController controller = new TECProvidedController(type);

            TECConnectionType connectionType = new TECConnectionType();
            TECDevice         device         = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());

            TECSubScope subScope = new TECSubScope();

            subScope.AddDevice(device);

            controller.Connect(subScope, subScope.HardwiredProtocol());

            TECDevice otherDevice = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());

            subScope.AddDevice(otherDevice);

            Assert.IsFalse(subScope.Devices.Contains(otherDevice));

            TECConnectionType otherConnectionType = new TECConnectionType();
            TECDevice         nextDevice          = new TECDevice(new List <TECConnectionType> {
                otherConnectionType
            }, new List <TECProtocol>(), new TECManufacturer());
            bool deviceAdded = subScope.AddDevice(nextDevice);

            Assert.IsFalse(deviceAdded);
            Assert.IsFalse(subScope.Devices.Contains(nextDevice));
        }
Esempio n. 22
0
        public void RemoveSubScope()
        {
            //Arrange

            TECTypical typical = new TECTypical();

            bid.Systems.Add(typical);

            TECEquipment typEquip = new TECEquipment();

            typical.Equipment.Add(typEquip);

            TECSubScope subScope = ModelCreation.TestSubScope(bid.Catalogs, rand);

            subScope.AssignRandomScopeProperties(bid.Catalogs, rand);
            typEquip.SubScope.Add(subScope);

            typical.AddInstance();

            MaterialSummaryVM matVM = new MaterialSummaryVM(bid, cw);

            CostBatch initial = MatVMToCostBatch(matVM);

            //Act
            typEquip.SubScope.Remove(subScope);

            //Assert
            AssertMaterialVMMatchesCostBatch(matVM, initial - subScope.CostBatch);
        }
        public void RemovePointFromConnectedHardwired()
        {
            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(IOType.AI));
            TECProvidedController controller = new TECProvidedController(type);

            TECConnectionType connectionType = new TECConnectionType();
            TECDevice         device         = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());

            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(device);

            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.AddPoint(point);

            controller.Connect(subScope, subScope.HardwiredProtocol());

            subScope.RemovePoint(point);

            Assert.IsFalse(subScope.Points.Contains(point));
            Assert.IsTrue(controller.AvailableIO.IONumber(IOType.AI) == 1);
        }
        public void CompatibleProtocolsTest()
        {
            TECProtocol firstProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol secondProtocol = new TECProtocol(new List <TECConnectionType>());
            TECProtocol thirdProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol fourthProtocol = new TECProtocol(new List <TECConnectionType>());

            TECDevice compatibleDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                secondProtocol, firstProtocol
            }, new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);


            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(firstProtocol));
            type.IO.Add(new TECIO(secondProtocol));
            type.IO.Add(new TECIO(thirdProtocol));

            TECProvidedController controller = new TECProvidedController(type);

            var compatible = controller.CompatibleProtocols(subScope);

            Assert.AreEqual(2, compatible.Count);
            Assert.IsTrue(compatible.Contains(firstProtocol) && compatible.Contains(secondProtocol));
        }
        public void AvailableProtocols2()
        {
            TECSubScope ss = new TECSubScope();

            Assert.IsFalse(ss.AvailableProtocols.Any(prot => { return(prot is TECHardwiredProtocol); }));
            Assert.AreEqual(0, ss.AvailableProtocols.Count);
        }
        public void CompatibleProtocolsTest2()
        {
            TECConnectionType connectionType   = new TECConnectionType();
            TECDevice         compatibleDevice = new TECDevice(new List <TECConnectionType> {
                connectionType
            }, new List <TECProtocol>(), new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);
            TECPoint point = new TECPoint();

            point.Type = IOType.AI;
            subScope.Points.Add(point);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(IOType.AI));

            TECProvidedController controller = new TECProvidedController(type);

            var compatible = controller.CompatibleProtocols(subScope);

            Assert.AreEqual(1, compatible.Count);
            Assert.IsTrue(compatible.Any(x => x is TECHardwiredProtocol));
        }
 public AddSubScopeVM(Action <TECSubScope> addMethod, TECScopeManager scopeManager) : base(scopeManager)
 {
     add   = addMethod;
     toAdd = new TECSubScope();
     setup();
     PropertiesVM.DisplayReferenceProperty = false;
 }
        public void ConnectTest1()
        {
            TECProtocol firstProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol secondProtocol = new TECProtocol(new List <TECConnectionType>());
            TECProtocol thirdProtocol  = new TECProtocol(new List <TECConnectionType>());
            TECProtocol fourthProtocol = new TECProtocol(new List <TECConnectionType>());

            TECDevice compatibleDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>()
            {
                fourthProtocol
            }, new TECManufacturer());
            TECSubScope subScope = new TECSubScope();

            subScope.Devices.Add(compatibleDevice);

            TECControllerType type = new TECControllerType(new TECManufacturer());

            type.IO.Add(new TECIO(firstProtocol));
            type.IO.Add(new TECIO(secondProtocol));
            type.IO.Add(new TECIO(thirdProtocol));

            TECProvidedController controller = new TECProvidedController(type);
            var connection = controller.Connect(subScope, firstProtocol);

            Assert.IsNull(connection);
        }
Esempio n. 29
0
        public void SaveAs_Bid_SubScope()
        {
            //Arrange
            TECBid bid = new TECBid();

            bid.Catalogs = ModelCreation.TestCatalogs(rand, 5);
            TECTypical   system            = new TECTypical();
            TECEquipment expectedEquipment = new TECEquipment();
            TECSubScope  expectedSubScope  = ModelCreation.TestSubScope(bid.Catalogs, rand);

            expectedEquipment.SubScope.Add(expectedSubScope);
            system.Equipment.Add(expectedEquipment);

            bid.Systems.Add(system);

            path = Path.GetTempFileName();

            //Act
            DatabaseManager <TECBid> manager = new DatabaseManager <TECBid>(path);

            manager.New(bid);
            TECBid loadedBid = manager.Load() as TECBid;

            TECSubScope actualSubScope = loadedBid.FindChild(expectedSubScope.Guid) as TECSubScope;

            //Assert
            Assert.AreEqual(expectedSubScope.Name, actualSubScope.Name);
            Assert.AreEqual(expectedSubScope.Description, actualSubScope.Description);
            Assert.AreEqual(expectedSubScope.Interlocks.Count, actualSubScope.Interlocks.Count);
            Assert.AreEqual(expectedSubScope.ScopeBranches.Count, actualSubScope.ScopeBranches.Count);
            Assert.IsTrue(compareCosts(expectedSubScope.CostBatch, actualSubScope.CostBatch));
        }
Esempio n. 30
0
        public void TemplatedSubScopeRemovedFromTemplateEquipment()
        {
            //Arrange
            TECTemplates templates = new TECTemplates();
            TemplateSynchronizer <TECEquipment> equipSynchronizer = templates.EquipmentSynchronizer;
            TemplateSynchronizer <TECSubScope>  ssSynchronizer    = templates.SubScopeSynchronizer;

            TECEquipment templateEquip = new TECEquipment();

            templates.Templates.EquipmentTemplates.Add(templateEquip);

            TECSubScope templateSS = new TECSubScope();

            templates.Templates.SubScopeTemplates.Add(templateSS);

            TECSubScope instanceSS = ssSynchronizer.NewItem(templateSS);

            templateEquip.SubScope.Add(instanceSS);

            TECEquipment instanceEquip = equipSynchronizer.NewItem(templateEquip);

            templates.Templates.EquipmentTemplates.Add(instanceEquip);

            //Act
            templateEquip.SubScope.Remove(instanceSS);

            //Assert
            Assert.IsTrue(instanceEquip.SubScope.Count == 0, "SubScope not removed properly from equipment reference.");

            Assert.IsFalse(ssSynchronizer.Contains(instanceSS), "Reference SubScope not removed properly from synchronizer.");
            Assert.IsTrue(ssSynchronizer.Contains(templateSS), "Template SubScope was removed from synchronizer when it shouldn't have been.");
        }