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 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)); }
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 static void ConnectEquipmentToController(TECEquipment equipment, TECController controller) { foreach (TECSubScope subscope in equipment.SubScope) { controller.Connect(subscope, (subscope as IConnectable).AvailableProtocols.First()); } }
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"); }
private void addExecute() { for (int x = 0; x < Quantity; x++) { TECEquipment equipment = null; if (AsReference && underlyingTemplate != null) { equipment = templates.EquipmentSynchronizer.NewItem(underlyingTemplate); } else if (underlyingTemplate != null) { if (templates != null) { equipment = new TECEquipment(underlyingTemplate, ssSynchronizer: templates.SubScopeSynchronizer); } else { equipment = new TECEquipment(underlyingTemplate); } } else { equipment = new TECEquipment(ToAdd); } equipment.CopyPropertiesFromScope(ToAdd); add(equipment); if (ConnectVM != null && ConnectVM.Connect) { ConnectVM.ExecuteConnection(equipment.SubScope); } Added?.Invoke(equipment); } }
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); }
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 TemplateEquipmentRemoved() { //Arrange TECTemplates templates = new TECTemplates(); TemplateSynchronizer <TECEquipment> synchronizer = templates.EquipmentSynchronizer; TECEquipment templateEquip = new TECEquipment(); templateEquip.Name = "First Name"; templates.Templates.EquipmentTemplates.Add(templateEquip); TECSystem templateSys = new TECSystem(); templates.Templates.SystemTemplates.Add(templateSys); TECEquipment equip1 = synchronizer.NewItem(templateEquip); TECEquipment equip2 = synchronizer.NewItem(templateEquip); templateSys.Equipment.Add(equip1); templateSys.Equipment.Add(equip2); //Act templates.Templates.EquipmentTemplates.Remove(templateEquip); equip2.Name = "Second Name"; //Assert Assert.IsFalse(synchronizer.Contains(templateEquip)); Assert.IsFalse(synchronizer.Contains(equip1)); Assert.IsFalse(synchronizer.Contains(equip2)); Assert.AreEqual("First Name", equip1.Name); Assert.AreEqual("Second Name", equip2.Name); }
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."); }
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 TemplateSubScopeRemoved() { //Arrange TECTemplates templates = new TECTemplates(); TemplateSynchronizer <TECSubScope> synchronizer = templates.SubScopeSynchronizer; TECSubScope templateSS = new TECSubScope(); templateSS.Name = "First Name"; templates.Templates.SubScopeTemplates.Add(templateSS); TECEquipment templateEquip = new TECEquipment(); templates.Templates.EquipmentTemplates.Add(templateEquip); TECSubScope ss1 = synchronizer.NewItem(templateSS); TECSubScope ss2 = synchronizer.NewItem(templateSS); templateEquip.SubScope.Add(ss1); templateEquip.SubScope.Add(ss2); //Act templates.Templates.SubScopeTemplates.Remove(templateSS); ss2.Name = "Second Name"; //Assert Assert.IsFalse(synchronizer.Contains(templateSS)); Assert.IsFalse(synchronizer.Contains(ss1)); Assert.IsFalse(synchronizer.Contains(ss2)); Assert.AreEqual("First Name", ss1.Name); Assert.AreEqual("Second Name", ss2.Name); }
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 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 Undo_Template_System_Equipment() { //Arrange var Template = ModelCreation.TestTemplates(rand); var system = Template.Templates.SystemTemplates[0]; ObservableCollection <TECEquipment> expected = new ObservableCollection <TECEquipment>(); foreach (TECEquipment item in system.Equipment) { expected.Add(item); } TECEquipment edit = new TECEquipment(); //Act ChangeWatcher watcher = new ChangeWatcher(Template); DoStacker testStack = new DoStacker(watcher); system.Equipment.Add(edit); Assert.AreEqual(1, testStack.UndoCount(), "Not added to undo stack"); testStack.Undo(); //assert var actual = system.Equipment; Assert.AreEqual(expected.Count, actual.Count, "Not Undone"); }
private static void linkEquipmentToCatalogs(TECEquipment equip, TECCatalogs catalogs) { linkScopeChildrenToCatalogs(equip, catalogs); foreach (TECSubScope subScope in equip.SubScope) { linkSubScopeToCatalogs(subScope, catalogs); } }
private void addSubScopeExecute(TECEquipment equipment) { SelectedVM = new AddSubScopeVM(equipment, scopeManager); (SelectedVM as AddVM).Added = subScope => { SelectedSubScope = subScope as TECSubScope; }; }
public AddEquipmentVM(Action <TECEquipment> addMethod, TECScopeManager scopeManager) : base(scopeManager) { toAdd = new TECEquipment(); add = addMethod; AddCommand = new RelayCommand(addExecute, addCanExecute); Quantity = 1; PropertiesVM.DisplayReferenceProperty = false; }
private static void linkLocation(TECEquipment equipment, IEnumerable <TECLocation> locations) { linkLocation(equipment as TECLocated, locations); foreach (TECSubScope ss in equipment.SubScope) { linkLocation(ss, locations); } }
public static TECEquipment TestEquipment(TECCatalogs catalogs, Random rand) { TECEquipment equip = new TECEquipment(); equip.Description = "Test Equipment"; equip.AssignRandomScopeProperties(catalogs, rand); rand.RepeatAction(() => equip.SubScope.Add(TestSubScope(catalogs, rand)), 5); return(equip); }
public static void LinkScopeItem(TECEquipment scope, TECBid bid) { linkScopeChildrenToCatalogs(scope, bid.Catalogs); linkLocation(scope, bid.Locations); foreach (TECSubScope ss in scope.SubScope) { LinkScopeItem(ss, bid); } }
public void DeleteDeviceUserInputNo() { //Arrange TECTemplates templatesManager = new TECTemplates(); TECScopeTemplates templates = templatesManager.Templates; TECManufacturer man = new TECManufacturer(); templatesManager.Catalogs.Add(man); TECDevice dev = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>(), man); templatesManager.Catalogs.Add(dev); TECSystem sys = new TECSystem(); templates.SystemTemplates.Add(sys); TECEquipment sysEquip = new TECEquipment(); sys.Equipment.Add(sysEquip); TECSubScope sysSS = new TECSubScope(); sysEquip.SubScope.Add(sysSS); sysSS.Devices.Add(dev); TECEquipment equip = new TECEquipment(); templates.EquipmentTemplates.Add(equip); TECSubScope equipSS = new TECSubScope(); equip.SubScope.Add(equipSS); equipSS.Devices.Add(dev); TECSubScope ss = new TECSubScope(); templates.SubScopeTemplates.Add(ss); ss.Devices.Add(dev); //Act Mock <IUserConfirmable> mockMessageBox = new Mock <IUserConfirmable>(); mockMessageBox .Setup(x => x.Show(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <MessageBoxButton>(), It.IsAny <MessageBoxImage>())) .Returns(MessageBoxResult.No); DeleteEndDeviceVM vm = new DeleteEndDeviceVM(dev, templatesManager); vm.messageBox = mockMessageBox.Object; vm.DeleteCommand.Execute(null); //Assert Assert.IsTrue(templatesManager.Catalogs.Devices.Contains(dev), "Device not removed from device templates properly."); Assert.IsTrue(sysSS.Devices.Contains(dev), "Device not removed from system template properly."); Assert.IsTrue(equipSS.Devices.Contains(dev), "Device not removed from equipment template properly."); Assert.IsTrue(ss.Devices.Contains(dev), "Device not removed from subscope template properly."); }
public AddSubScopeVM(TECEquipment parentEquipment, TECScopeManager scopeManager) : base(scopeManager) { parent = parentEquipment; toAdd = new TECSubScope(); add = subScope => { parent.SubScope.Add(subScope); }; setup(); }
public void RemoveEquipmentTest() { TECSystem system = new TECSystem(); TECEquipment equipment = new TECEquipment(); system.Equipment.Add(equipment); system.ProposalItems.Add(new TECProposalItem(equipment)); system.Equipment.Remove(equipment); Assert.IsTrue(system.ProposalItems.Count == 0); }
public void SubScopeTemplateChanged() { //Arrange TECTemplates templates = new TECTemplates(); TECSubScope templateSS = new TECSubScope(); templateSS.Name = "Template SubScope"; templates.Templates.SubScopeTemplates.Add(templateSS); TemplateSynchronizer <TECSubScope> ssSynchronizer = templates.SubScopeSynchronizer; TECSubScope refSS = ssSynchronizer.NewItem(templateSS); TECEquipment equip = new TECEquipment(); templates.Templates.EquipmentTemplates.Add(equip); equip.SubScope.Add(refSS); TECDevice dev = new TECDevice(new List <TECConnectionType>(), new List <TECProtocol>(), new TECManufacturer()); templates.Catalogs.Add(dev); TECPoint point = new TECPoint(); point.Label = "Test Point"; point.Type = IOType.AI; point.Quantity = 5; TECAssociatedCost cost = new TECAssociatedCost(CostType.TEC); templates.Catalogs.Add(cost); TECTag tag = new TECTag(); templates.Catalogs.Add(tag); //Act templateSS.Description = "Test Description"; templateSS.Devices.Add(dev); templateSS.AddPoint(point); templateSS.AssociatedCosts.Add(cost); templateSS.Tags.Add(tag); //Assert //Assert.AreEqual(templateSS.Description, refSS.Description, "Description didn't sync properly between SubScope."); Assert.AreEqual(templateSS.Devices[0], refSS.Devices[0], "Devices didn't sync properly between SubScope."); Assert.AreEqual(templateSS.Points[0].Label, refSS.Points[0].Label, "Points didn't sync properly between SubScope."); Assert.AreEqual(templateSS.Points[0].Type, refSS.Points[0].Type, "Points didn't sync properly between SubScope."); Assert.AreEqual(templateSS.Points[0].Quantity, refSS.Points[0].Quantity, "Points didn't sync properly between SubScope."); Assert.AreEqual(templateSS.AssociatedCosts[0], refSS.AssociatedCosts[0], "Associated costs didn't sync properly between SubScope."); Assert.AreEqual(templateSS.Tags[0], refSS.Tags[0], "Tags didn't sync properly between SubScope."); }
public void SetTemplate(TECEquipment template) { underlyingTemplate = template; ToAdd = new TECEquipment(template); if (IsTemplates) { DisplayReferenceProperty = true; } if (ConnectVM != null) { ConnectVM.Update(ToAdd.SubScope); } }
public void SaveNew_Templates_System() { //Arrange TECEquipment expectedSysEquipment = expectedSystem.Equipment.First(); TECSubScope expectedSysSubScope = expectedSysEquipment.SubScope.First(); TECDevice expectedChildDevice = expectedSysSubScope.Devices[0] as TECDevice; TECPoint expectedSysPoint = expectedSysSubScope.Points.First(); TECManufacturer expectedChildMan = expectedChildDevice.Manufacturer; TECEquipment actualSysEquipment = actualSystem.Equipment.First(item => item.Guid == expectedSysEquipment.Guid); TECSubScope actualSysSubScope = actualSysEquipment.SubScope.First(item => item.Guid == expectedSysSubScope.Guid); TECDevice actualChildDevice = actualSysSubScope.Devices[0] as TECDevice; TECPoint actualSysPoint = actualSysSubScope.Points.First(item => item.Guid == expectedSysPoint.Guid); TECManufacturer actualChildMan = actualChildDevice.Manufacturer; //Assert Assert.AreEqual(expectedSystem.Name, actualSystem.Name); Assert.AreEqual(expectedSystem.Description, actualSystem.Description); Assert.AreEqual(expectedSystem.Tags[0].Label, actualSystem.Tags[0].Label); Assert.AreEqual(expectedSysEquipment.Name, actualSysEquipment.Name); Assert.AreEqual(expectedSysEquipment.Description, actualSysEquipment.Description); Assert.AreEqual(expectedSysEquipment.Tags[0].Label, actualSysEquipment.Tags[0].Label); Assert.AreEqual(expectedSysSubScope.Name, actualSysSubScope.Name); Assert.AreEqual(expectedSysSubScope.Description, actualSysSubScope.Description); Assert.AreEqual(expectedSysSubScope.Tags[0].Label, actualSysSubScope.Tags[0].Label); Assert.AreEqual(expectedChildDevice.Name, actualChildDevice.Name); Assert.AreEqual(expectedChildDevice.Description, actualChildDevice.Description); Assert.AreEqual(expectedChildDevice.Cost, actualChildDevice.Cost, DELTA); Assert.AreEqual(expectedChildDevice.HardwiredConnectionTypes[0].Guid, actualChildDevice.HardwiredConnectionTypes[0].Guid); Assert.AreEqual(expectedChildDevice.Tags[0].Label, actualChildDevice.Tags[0].Label); Assert.AreEqual(expectedSysPoint.Label, actualSysPoint.Label); Assert.AreEqual(expectedSysPoint.Quantity, actualSysPoint.Quantity); Assert.AreEqual(expectedSysPoint.Type, actualSysPoint.Type); Assert.AreEqual(expectedChildMan.Label, actualChildMan.Label); Assert.AreEqual(expectedChildMan.Multiplier, actualChildMan.Multiplier, DELTA); ////Controlled scope tests] //TECSystem expectedConScope = expectedSystem; //TECSystem actualConScope = actualSystem; //Assert.AreEqual(expectedConScope.Name, actualConScope.Name); //Assert.AreEqual(expectedConScope.Description, actualConScope.Description); //Assert.AreEqual(expectedConScope.Equipment[0].Name, actualConScope.Equipment[0].Name); //Assert.AreEqual(expectedConScope.Panels[0].Name, actualConScope.Panels[0].Name); //Assert.AreEqual(expectedConScope.Controllers[0].Name, actualConScope.Controllers[0].Name); //Assert.AreEqual(42, actualConScope.Controllers[0].ChildrenConnections[0].Length); }
public static void ClassInitialize(TestContext TestContext) { rand = new Random(0); //Arrange expectedTemplates = ModelCreation.TestTemplates(rand); ModelCreation.AddSyncronizerItems(expectedTemplates); expectedSystem = expectedTemplates.Templates.SystemTemplates.First(); expectedEquipment = expectedTemplates.Templates.EquipmentTemplates.First(); expectedSubScope = expectedTemplates.Templates.SubScopeTemplates.First(); expectedDevice = expectedTemplates.Catalogs.Devices.First(); expectedManufacturer = expectedTemplates.Catalogs.Manufacturers.First(); expectedTag = expectedTemplates.Catalogs.Tags[0]; expectedController = (TECProvidedController)expectedTemplates.Templates.ControllerTemplates.First(sys => sys is TECProvidedController); expectedAssociatedCost = expectedTemplates.Catalogs.AssociatedCosts[0]; expectedConnectionType = expectedTemplates.Catalogs.ConnectionTypes[0]; expectedConduitType = expectedTemplates.Catalogs.ConduitTypes[0]; path = Path.GetTempFileName(); //Act DatabaseManager <TECTemplates> manager = new DatabaseManager <TECTemplates>(path); bool success = manager.New(expectedTemplates); Assert.IsTrue(success, "New method in DatabaseManager returned false."); actualTemplates = manager.Load(); if (actualTemplates.Templates.SystemTemplates.Count == 0) { string failDirectory = Path.GetTempPath() + "Estimating Tools\\"; Directory.CreateDirectory(failDirectory); string failPath = failDirectory + "SaveNewTemplatesTestFailed.tdb"; if (File.Exists(failPath)) { File.Delete(failPath); } File.Copy(path, failPath); Assert.Fail(string.Format("No systems loaded into templates. File saved at: {0}", failPath)); } actualSystem = actualTemplates.Templates.SystemTemplates.First(x => x.Guid == expectedSystem.Guid); actualEquipment = actualTemplates.Templates.EquipmentTemplates.First(x => x.Guid == expectedEquipment.Guid); actualSubScope = actualTemplates.Templates.SubScopeTemplates.First(x => x.Guid == expectedSubScope.Guid); actualDevice = actualTemplates.Catalogs.Devices.First(x => x.Guid == expectedDevice.Guid); actualManufacturer = actualTemplates.Catalogs.Manufacturers.First(x => x.Guid == expectedManufacturer.Guid); actualTag = actualTemplates.Catalogs.Tags.First(x => x.Guid == expectedTag.Guid); actualController = actualTemplates.Templates.ControllerTemplates.First(x => x.Guid == expectedController.Guid) as TECProvidedController; actualAssociatedCost = actualTemplates.Catalogs.AssociatedCosts.First(x => x.Guid == expectedAssociatedCost.Guid); actualConnectionType = actualTemplates.Catalogs.ConnectionTypes.First(x => x.Guid == expectedConnectionType.Guid); actualConduitType = actualTemplates.Catalogs.ConduitTypes.First(x => x.Guid == expectedConduitType.Guid); }
public void DragDropCopyTest() { Random rand = new Random(0); TECBid bid = ModelCreation.TestBid(rand); TECEquipment equip = ModelCreation.TestEquipment(bid.Catalogs, rand); bid.Systems.First().Equipment.Add(equip); TECEquipment copy = equip.DropData() as TECEquipment; Assert.AreEqual(equip.Name, copy.Name); Assert.AreEqual(equip.SubScope.Count, copy.SubScope.Count); Assert.IsTrue(equip.CostBatch.CostsEqual(copy.CostBatch)); }
private void testNetworkExecute() { TECControllerType type = new TECControllerType(bid.Catalogs.Manufacturers[0]); type.Name = "Controller Type"; type.IO.Add(new TECIO(IOType.AI)); bid.Catalogs.Add(type); TECProvidedController controller = new TECProvidedController(type); controller.Name = "Test Server"; controller.Description = "For testing."; controller.IsServer = true; bid.AddController(controller); TECProvidedController child = new TECProvidedController(type); child.Name = "Child"; bid.AddController(child); TECProvidedController emptyController = new TECProvidedController(type); emptyController.Name = "EmptyController"; bid.AddController(emptyController); TECNetworkConnection connection = controller.AddNetworkConnection(bid.Catalogs.Protocols[0]); connection.AddChild(child); TECTypical typical = new TECTypical(); TECEquipment equip = new TECEquipment(); TECSubScope ss = new TECSubScope(); ss.Name = "Test Subscope"; ss.AddDevice(bid.Catalogs.Devices[0]); TECPoint point = new TECPoint(); point.Type = IOType.AI; point.Quantity = 1; ss.AddPoint(point); equip.SubScope.Add(ss); typical.Equipment.Add(equip); bid.Systems.Add(typical); typical.AddInstance(); }