public void AddsNewConnector()
        {
            RegionModel addedRegion = SetupRegion(m_applier, m_model, 1);

            ConnectorModel addedConnector1 = new InputConnectorModel(addedRegion, "input", 4);
            ConnectorModel addedConnector2 = new OutputConnectorModel(addedRegion, "output", 3);

            ResponseMessage diff =
                ModelResponseBuilder.Build(addedConnectors: new List <ConnectorModel> {
                addedConnector1, addedConnector2
            });

            ApplyModelDiff(diff);

            RegionModel region = m_model.Regions.First();

            Assert.Equal(1, region.InputConnectors.Models.Count());
            Assert.Equal(1, region.OutputConnectors.Models.Count());

            ComparisonResult result1 = CompareLogic(ConnectorComparisonConfig)
                                       .Compare(addedConnector1, region.InputConnectors.First());
            ComparisonResult result2 = CompareLogic(ConnectorComparisonConfig)
                                       .Compare(addedConnector2, region.OutputConnectors.First());

            Assert.True(result1.AreEqual, result1.DifferencesString);
            Assert.True(result2.AreEqual, result2.DifferencesString);
        }
Пример #2
0
        private void ProcessConnection(SimulationModel model, Connection connection, string actionName, Action <OutputConnectorModel, InputConnectorModel> action)
        {
            // TODO(HonzaS): These two mean connections to the sensors/actuators, add support for those
            if (connection.FromRegion == 0 || connection.ToRegion == 0)
            {
                return;
            }

            RegionModel fromRegion = model.Regions[connection.FromRegion];
            RegionModel toRegion   = model.Regions[connection.ToRegion];

            if (fromRegion == null || toRegion == null)
            {
                string missingRegion = fromRegion == null ? "Source" : "Target";
                LogConnectionNotProcessed(connection, actionName, $"{missingRegion} region not found");
                return;
            }

            OutputConnectorModel fromConnector =
                fromRegion.OutputConnectors.FirstOrDefault(connector => connector.Name == connection.FromConnector);

            InputConnectorModel toConnector =
                toRegion.InputConnectors.FirstOrDefault(connector => connector.Name == connection.ToConnector);

            if (fromConnector == null || toConnector == null)
            {
                string missingConnector = fromConnector == null ? "Source" : "Target";
                LogConnectionNotProcessed(connection, actionName, $"{missingConnector} connector not found");
                return;
            }

            action(fromConnector, toConnector);
        }
        private ConnectionModel SetupRegionsWithConnectors()
        {
            RegionModel addedRegion1 = SetupRegion(m_applier, m_model, 1);
            RegionModel addedRegion2 = SetupRegion(m_applier, m_model, 2);

            var addedConnector1 = new OutputConnectorModel(addedRegion1, "output", 3);
            var addedConnector2 = new InputConnectorModel(addedRegion2, "input", 4);

            var addedConnection = new ConnectionModel(addedConnector1, addedConnector2);

            ResponseMessage diff =
                ModelResponseBuilder.Build(
                    addedConnectors: new List <ConnectorModel> {
                addedConnector1, addedConnector2
            },
                    addedConnections: new List <ConnectionModel> {
                addedConnection
            });

            ApplyModelDiff(diff);
            return(addedConnection);
        }