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 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 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()); }
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)); }
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 AddRemoveSystemInstanceWithBidConnection() { var bid = new TECBid(); bid.Catalogs = ModelCreation.TestCatalogs(rand); var bidController = new TECProvidedController(bid.Catalogs.ControllerTypes.RandomElement(rand)); bid.AddController(bidController); var system = new TECTypical(); var equipment = new TECEquipment(); var subScope = new TECSubScope(); TECDevice dev = bid.Catalogs.Devices.First(x => x.HardwiredConnectionTypes.Count > 0); subScope.Devices.Add(dev); TECHardwiredProtocol hardProt = subScope.AvailableProtocols.First(x => x is TECHardwiredProtocol) as TECHardwiredProtocol; system.Equipment.Add(equipment); equipment.SubScope.Add(subScope); var instance = system.AddInstance(); var instanceSubScope = instance.GetAllSubScope().First(); bidController.Connect(instanceSubScope, hardProt); Assert.AreEqual(1, bidController.ChildrenConnections.Count, "Connection not added"); system.Instances.Remove(instance); Assert.AreEqual(0, bidController.ChildrenConnections.Count, "Connection not removed"); }
public void RemoveInstanceWithGlobalConnectionToController() { TECBid bid = new TECBid(); bid.Catalogs = ModelCreation.TestCatalogs(rand); TECControllerType type = bid.Catalogs.ControllerTypes.RandomElement(rand); TECController controller = new TECProvidedController(type); bid.AddController(controller); TECTypical typical = new TECTypical(); TECController typicalController = new TECProvidedController(type); typical.AddController(typicalController); bid.Systems.Add(typical); TECSystem system = typical.AddInstance(); TECController instanceController = typical.GetInstancesFromTypical(typicalController).First(); Assert.IsTrue(controller.CanConnect(instanceController)); IControllerConnection connection = controller.Connect(instanceController, instanceController.AvailableProtocols.First()); Assert.IsTrue(connection is TECNetworkConnection); typical.Instances.Remove(system); Assert.IsTrue((connection as TECNetworkConnection).Children.Count == 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)); }
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)); }
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); }
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); }
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 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 void CopyProvidedControllerTest() { //Arrange TECCatalogs catalogs = ModelCreation.TestCatalogs(rand); TECProvidedController controller = ModelCreation.TestProvidedController(catalogs, rand); TECProvidedController copy = controller.CopyController(new Dictionary <Guid, Guid>()) as TECProvidedController; //TECTagged Assert.AreEqual(controller.Name, copy.Name); Assert.AreEqual(controller.Description, copy.Description); Assert.IsTrue(controller.Tags.SequenceEqual(copy.Tags)); //TECScope Assert.IsTrue(controller.AssociatedCosts.SequenceEqual(copy.AssociatedCosts)); //TECLocated Assert.AreEqual(controller.Location, copy.Location); //TECController Assert.AreEqual(controller.IsServer, copy.IsServer); //TECFBOController Assert.AreEqual(controller.Type, copy.Type); Assert.IsTrue(controller.IOModules.SequenceEqual(copy.IOModules)); }
public void Controller_RemoveAllConnections() { TECControllerType type = new TECControllerType(new TECManufacturer()); type.IO.Add(new TECIO(IOType.AI)); type.IO.Add(new TECIO(IOType.AI)); TECController controller = new TECProvidedController(type); TECController childController = new TECProvidedController(type); TECController childestController = new TECProvidedController(type); TECProtocol protocol = new TECProtocol(new List <TECConnectionType> { }); type.IO.Add(new TECIO(protocol)); TECNetworkConnection connection = controller.AddNetworkConnection(protocol); connection.AddChild(childController); TECNetworkConnection childConnection = childController.AddNetworkConnection(protocol); childConnection.AddChild(childestController); childController.DisconnectAll(); Assert.AreEqual(0, childController.ChildrenConnections.Count, "Connection not removed from controller"); Assert.AreEqual(null, childController.ParentConnection, "Connection not removed from child"); Assert.AreEqual(null, childestController.ParentConnection, "Connection not removed from childest"); }
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); }
public ChangeControllerTypeVM(TECProvidedController controller, IEnumerable <TECControllerType> types) { this.Controller = controller; this.Types = getCompatibleTypes(types); ChangeCommand = new RelayCommand <TECControllerType>(changeTypeExecute, canChangeType); }
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 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); }
public static TECProvidedController TestProvidedController(TECCatalogs catalogs, Random rand) { TECProvidedController controller = new TECProvidedController(catalogs.ControllerTypes.RandomElement(rand)); controller.Description = "Test Provided Controller"; controller.AssignRandomScopeProperties(catalogs, rand); return(controller); }
internal static bool addRequiredIOModules(TECProvidedController controller) { //The IO needed by the points connected to the controller IOCollection necessaryIO = new IOCollection(); bool needsSave = false; foreach (TECHardwiredConnection ssConnect in controller.ChildrenConnections.Where(con => con is TECHardwiredConnection)) { foreach (TECIO io in ssConnect.Child.HardwiredIO.ToList()) { for (int i = 0; i < io.Quantity; i++) { //The point IO that exists on our controller at the moment. IOCollection totalPointIO = getPointIO(controller); necessaryIO.Add(io.Type); //Check if our io that exists satisfies the IO that we need. if (!totalPointIO.Contains(necessaryIO)) { needsSave = true; bool moduleFound = false; //If it doesn't, we need to add an IO module that will satisfy it. foreach (TECIOModule module in controller.Type.IOModules) { //We only need to check for the type of the last IO that we added. if (module.IOCollection.Contains(io.Type) && controller.CanAddModule(module)) { controller.AddModule(module); moduleFound = true; break; } } if (!moduleFound) { controller.DisconnectAll(); MessageBox.Show(string.Format("The controller type of the controller '{0}' is incompatible with the connected points. Please review the controller's connections.", controller.Name)); return(true); } } } } } return(needsSave); IOCollection getPointIO(TECController con) { IOCollection pointIOCollection = new IOCollection(); foreach (TECIO pointIO in controller.IO.ToList().Where(io => (TECIO.PointIO.Contains(io.Type) || TECIO.UniversalIO.Contains(io.Type)))) { pointIOCollection.Add(pointIO); } return(pointIOCollection); } }
public ProvidedControllerPropertiesItem(TECProvidedController controller) { Controller = controller; AddModuleCommand = new RelayCommand <TECIOModule>(addModuleExecute, canAddModule); RemoveModuleCommand = new RelayCommand <TECIOModule>(removeModuleExecute, canRemoveModule); OptimizeModulesCommand = new RelayCommand(optimizeModulesExecute); populateIO(); populateModules(); }
public static TECController CreateTestController(bool isTypical, TECCatalogs catalogs) { var type = catalogs.ControllerTypes[0]; var controller = new TECProvidedController(type, isTypical); controller.Tags.Add(catalogs.Tags[0]); return(controller); }
public void RemoveAllChildHardwiredConnectionsTest() { 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; TECDevice compatibleHardDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>(), new TECManufacturer()); TECSubScope hardSubScope = new TECSubScope(); hardSubScope.Devices.Add(compatibleDevice); TECPoint point = new TECPoint(); point.Type = IOType.AI; hardSubScope.Points.Add(point); type.IO.Add(new TECIO(IOType.AI)); TECHardwiredConnection hardConnection = controller.Connect(hardSubScope, hardSubScope.HardwiredProtocol()) as TECHardwiredConnection; TECController parentController = new TECProvidedController(type); parentController.Connect(controller, secondProtocol); Assert.IsNotNull(controller.ParentConnection); controller.RemoveAllChildHardwiredConnections(); Assert.IsTrue(connection.Children.Contains(subScope)); Assert.IsTrue(controller.ChildrenConnections.Contains(connection)); Assert.AreEqual((subScope as IConnectable).GetParentConnection(), connection); Assert.IsFalse(controller.ChildrenConnections.Contains(hardConnection)); Assert.IsNull((hardSubScope as IConnectable).GetParentConnection()); Assert.IsNotNull(controller.ParentConnection); }
public void ControllerInPanel_AddPanel() { TECPanel panel = new TECPanel(new TECPanelType(new TECManufacturer())); TECController controller = new TECProvidedController(new TECControllerType(new TECManufacturer())); ControllerInPanel controllerInPanel = new ControllerInPanel(controller, null); controllerInPanel.Panel = panel; Assert.AreEqual(panel.Controllers.Count, 1, "Controller not added to panel"); }
public void ControllerInPanel_RemovePanel() { TECPanel panel = new TECPanel(new TECPanelType(new TECManufacturer())); TECController controller = new TECProvidedController(new TECControllerType(new TECManufacturer())); ControllerInPanel controllerInPanel = new ControllerInPanel(controller, panel); controllerInPanel.Panel = null; Assert.AreEqual(panel.Controllers.Count, 0, "Controller not removed to panel"); }
public void ConnectToControllerTest1() { TECProtocol protocol = new TECProtocol(new List <TECConnectionType>()); TECProtocol otherProtocol = new TECProtocol(new List <TECConnectionType>()); TECDevice protDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>() { protocol }, new TECManufacturer()); TECDevice otherProtDevice = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>() { otherProtocol }, new TECManufacturer()); List <IConnectable> connectables = new List <IConnectable>(); TECSubScope item1 = new TECSubScope(); item1.Devices.Add(otherProtDevice); connectables.Add(item1); TECSubScope item2 = new TECSubScope(); item2.Devices.Add(protDevice); connectables.Add(item2); TECSubScope item3 = new TECSubScope(); item3.Devices.Add(protDevice); connectables.Add(item3); TECSubScope item4 = new TECSubScope(); item4.Devices.Add(protDevice); connectables.Add(item4); TECSubScope item5 = new TECSubScope(); item5.Devices.Add(protDevice); connectables.Add(item5); TECSubScope item6 = new TECSubScope(); item6.Devices.Add(protDevice); connectables.Add(item6); TECControllerType type = new TECControllerType(new TECManufacturer()); type.IO.Add(new TECIO(protocol)); TECProvidedController controller = new TECProvidedController(type); List <IControllerConnection> connections = ConnectionHelper.ConnectToController(connectables, controller, new ConnectionProperties()); foreach (var thing in connectables) { Assert.IsFalse(connections.Any(x => connectionContainsItem(x, thing))); } }
public void Bid_AddController() { TECControllerType controllerType = new TECControllerType(manufacturer); controllerType.Price = 100; TECController controller = new TECProvidedController(controllerType); bid.AddController(controller); Assert.AreEqual(100, costs.GetCost(CostType.TEC)); Assert.AreEqual(0, costs.GetCost(CostType.Electrical)); }
private static void linkProvidedControllerToControllerType(TECProvidedController controller, IEnumerable <TECControllerType> controllerTypes) { foreach (TECControllerType type in controllerTypes) { if (controller.Type.Guid == type.Guid) { if (!controller.ChangeType(type)) { logger.Error("Controller type isn't compatible with controller, can't change type."); } } } }