/// <summary>
/// Deserialize given XML list of glue realations.
/// </summary>
/// <param name="glueRelations">XML element list of glue realations.</param>
/// <exception cref="MissingXmlAttribute">If some attribute of floating object is missing.</exception>
/// <exception cref="MissingXmlElement">If some element of floating object is missing.</exception>
private void DeserializeGlueRelations(List <XElement> glueRelations)
{
GluePRelation = new GlueRelation();
foreach (XElement glueRelation in glueRelations)
{
string nameOfTheGlue1 = Xmlizer.GetAttributeValueWithException(glueRelation, "glueTuple", "glue1");
string nameOfTheGlue2 = Xmlizer.GetAttributeValueWithException(glueRelation, "glueTuple", "glue2");
if (!Glues.ContainsKey(nameOfTheGlue1))
{
throw new InvalidOperationException(string.Format("Glue named '{0}' is not defined in input xml file.",
nameOfTheGlue1));
}
if (!Glues.ContainsKey(nameOfTheGlue2))
{
throw new InvalidOperationException(string.Format("Glue named '{0}' is not defined in input xml file.",
nameOfTheGlue2));
}
Glue glue1 = Glues[nameOfTheGlue1];
Glue glue2 = Glues[nameOfTheGlue2];
GluePRelation[Tuple.Create(glue1, glue2)] = new NamedMultiset();
}
}
public void TestConstructor()
{
MSystem mSystem = new MSystem(v_TestDeserializedMSystemObjects);
// Tiles
ReadOnlyDictionary <string, Tile> tiles = mSystem.Tiles;
Assert.AreEqual(3, tiles.Count);
Tile tileQ1 = tiles["q1"];
var connectors = tileQ1.Connectors;
Assert.AreEqual(6, connectors.Count);
var connectorC1 = connectors[0];
Assert.AreEqual("c1", connectorC1.Name);
Assert.AreEqual(Tile.SideType.undef, connectorC1.Side);
Assert.AreEqual(v_TestDeserializedMSystemObjects.Glues["pa"], connectorC1.Glue);
Assert.AreEqual(Angle.FromRadians(2.034443935795703), connectorC1.Angle);
Assert.AreEqual(2, connectorC1.Positions.Count);
Assert.AreEqual(new Point3D(0, 10, 0), connectorC1.Positions[0]);
double posY = 10 * Math.Cos((1) * 2 * Math.PI / 5);
double posX = 10 * Math.Sin((1) * 2 * Math.PI / 5);
Assert.AreEqual(new Point3D(posX, posY, 0), connectorC1.Positions[1]);
Glue surfaceGLuePx = tileQ1.SurfaceGlue;
Assert.AreEqual("px", surfaceGLuePx.Name);
Assert.AreEqual(4, tileQ1.Proteins.Count);
Assert.AreEqual("p1", tileQ1.Proteins[0].Name);
Assert.AreEqual("p1", tileQ1.Proteins[1].Name);
Assert.AreEqual("p2", tileQ1.Proteins[2].Name);
Assert.AreEqual("p2", tileQ1.Proteins[3].Name);
foreach (var protein in tileQ1.Proteins)
{
Assert.AreEqual(Point3D.Origin, protein.Position);
}
Assert.AreEqual(Color.DeepSkyBlue, tileQ1.Color);
Tile tileS1 = tiles["s1"];
Assert.AreEqual(2, tileS1.Connectors.Count);
Assert.AreEqual(1, tileS1.Proteins.Count);
//Initial objects
IReadOnlyList <TileInSpace> seedTiles = mSystem.SeedTiles;
Assert.AreEqual(3, seedTiles.Count);
TileInSpace seedTileQ1 = seedTiles[0];
Assert.AreEqual("q1", seedTileQ1.Name);
Assert.AreEqual(new Point3D(0, 0, 0), seedTileQ1.Position.Round(14));
Assert.AreEqual(new EulerAngles(default(Angle), default(Angle), default(Angle)).ToQuaternion(), seedTileQ1.Quaternion);
//Environmental objects
var environmentalObjects = mSystem.FloatingObjects.Values.Where(obj => obj.Concentration > 0).ToList();
Assert.AreEqual(1, environmentalObjects.Count);
var environmentalObjectA = environmentalObjects[0];
Assert.AreEqual("b", environmentalObjectA.Name);
Assert.AreEqual(2, environmentalObjectA.Concentration);
//GlueRadius
Assert.AreEqual(0.1, mSystem.GlueRadius);
//Mobility
Assert.AreEqual(3, mSystem.Mobility);
//Tolerance
Assert.AreEqual(1E-10, MSystem.Tolerance);
//SideDist
Assert.AreEqual(5E-10, MSystem.SideDist);
//GlueRelation
GlueRelation glueTuples = mSystem.GlueRelation;
Assert.AreEqual(3, glueTuples.Count);
Tuple <Glue, Glue> glueTuplePaPb = glueTuples.Keys.ElementAt(0);
Assert.AreEqual("pa", glueTuplePaPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePaPb.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(0).ToDictionary()["a"]);
Tuple <Glue, Glue> glueTuplePaPa = glueTuples.Keys.ElementAt(1);
Assert.AreEqual("pa", glueTuplePaPa.Item1.Name);
Assert.AreEqual("pa", glueTuplePaPa.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(1).ToDictionary().Count);
Tuple <Glue, Glue> glueTuplePbPb = glueTuples.Keys.ElementAt(2);
Assert.AreEqual("pb", glueTuplePbPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePbPb.Item2.Name);
Assert.AreEqual(0, glueTuples.Values.ElementAt(2).ToDictionary().Count);
//MetabolicRules
Dictionary <string, IReadOnlyList <EvoMetabolicRule> > metabolicRules = mSystem.MetabolicRules;
Assert.AreEqual(2, metabolicRules.Count);
Assert.IsNotNull(metabolicRules["p1"]);
Assert.AreEqual(1, metabolicRules["p1"].Count);
Assert.IsNotNull(metabolicRules["p2"]);
Assert.AreEqual(0, metabolicRules["p2"].Count);
EvoMetabolicRule metabolicRule = metabolicRules["p1"][0];
Assert.AreEqual(0, metabolicRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Metabolic, metabolicRule.Type);
Assert.AreEqual(EvoMetabolicRule.MetabolicRuleType.Symport, metabolicRule.SubType);
Assert.AreEqual(2, metabolicRule.LeftSideObjects.Count);
Assert.AreEqual("a", metabolicRule.LeftSideObjects[0].Name);
Assert.AreEqual("p1", metabolicRule.LeftSideObjects[1].Name);
Assert.AreEqual(2, metabolicRule.RightSideObjects.Count);
Assert.AreEqual("p1", metabolicRule.RightSideObjects[0].Name);
Assert.AreEqual("a", metabolicRule.RightSideObjects[1].Name);
Assert.AreEqual(0, metabolicRule.MLeftInNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.ToDictionary()["a"]);
Assert.AreEqual(1, metabolicRule.MRightInNames.Count);
Assert.AreEqual(1, metabolicRule.MRightInNames.ToDictionary()["a"]);
Assert.AreEqual(0, metabolicRule.MRightOutNames.Count);
Assert.AreEqual("p1", metabolicRule.RProtein.Name);
//CreationRules
Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> > createRules = mSystem.CreationRules;
Assert.AreEqual(3, createRules.Count);
Glue pa = v_TestDeserializedMSystemObjects.Glues["pa"];
Glue pb = v_TestDeserializedMSystemObjects.Glues["pb"];
Glue px = v_TestDeserializedMSystemObjects.Glues["px"];
Assert.IsNotNull(createRules[pa]);
Assert.AreEqual(1, createRules[pa].Count);
Assert.IsNotNull(createRules[pb]);
Assert.AreEqual(1, createRules[pb].Count);
Assert.IsNotNull(createRules[px]);
Assert.AreEqual(0, createRules[px].Count);
// For different glues there is the same creation rule - this is OK.
EvoNonMetabolicRule createRulePA = createRules[pa][0];
Assert.AreEqual(1, createRulePA.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Create, createRulePA.Type);
Assert.AreEqual(3, createRulePA.LeftSideObjects.Count);
Assert.AreEqual("a", createRulePA.LeftSideObjects[0].Name);
Assert.AreEqual("a", createRulePA.LeftSideObjects[1].Name);
Assert.AreEqual("a", createRulePA.LeftSideObjects[2].Name);
Assert.AreEqual(1, createRulePA.RightSideObjects.Count);
Assert.AreEqual("q1", createRulePA.RightSideObjects[0].Name);
Assert.AreEqual(3, createRulePA.MLeftSideFloatingNames.Count);
Assert.AreEqual(3, createRulePA.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, createRulePA.MRightSideFloatingNames.Count);
// For different glues there is the same creation rule - this is OK.
EvoNonMetabolicRule createRulePB = createRules[pb][0];
Assert.AreEqual(1, createRulePB.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Create, createRulePB.Type);
Assert.AreEqual(3, createRulePB.LeftSideObjects.Count);
Assert.AreEqual("a", createRulePB.LeftSideObjects[0].Name);
Assert.AreEqual("a", createRulePB.LeftSideObjects[1].Name);
Assert.AreEqual("a", createRulePB.LeftSideObjects[2].Name);
Assert.AreEqual(1, createRulePB.RightSideObjects.Count);
Assert.AreEqual("q1", createRulePB.RightSideObjects[0].Name);
Assert.AreEqual(3, createRulePB.MLeftSideFloatingNames.Count);
Assert.AreEqual(3, createRulePB.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, createRulePB.MRightSideFloatingNames.Count);
//DestructionRules
var destructionRules = mSystem.DestructionRules;
Assert.AreEqual(3, destructionRules.Count);
Assert.IsNotNull(destructionRules["q1"]);
Assert.AreEqual(0, destructionRules["q1"].Count);
Assert.IsNotNull(destructionRules["s1"]);
Assert.AreEqual(1, destructionRules["s1"].Count);
EvoNonMetabolicRule destroyRule = destructionRules["s1"][0];
Assert.AreEqual(1, destroyRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Destroy, destroyRule.Type);
Assert.AreEqual(3, destroyRule.LeftSideObjects.Count);
Assert.AreEqual("a", destroyRule.LeftSideObjects[0].Name);
Assert.AreEqual("a", destroyRule.LeftSideObjects[1].Name);
Assert.AreEqual("s1", destroyRule.LeftSideObjects[2].Name);
Assert.AreEqual(2, destroyRule.RightSideObjects.Count);
Assert.AreEqual("c", destroyRule.RightSideObjects[0].Name);
Assert.AreEqual("c", destroyRule.RightSideObjects[1].Name);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.ToDictionary()["c"]);
//DivisionRules
var divisionRules = mSystem.DivisionRules;
Assert.AreEqual(1, divisionRules.Count);
Assert.IsNotNull(divisionRules[pa]);
Assert.AreEqual(1, divisionRules[pa].Count);
Assert.IsNotNull(divisionRules[pa][pa]);
Assert.AreEqual(1, divisionRules[pa][pa].Count);
EvoNonMetabolicRule divideRule = divisionRules[pa][pa][0];
Assert.AreEqual(1, divideRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Divide, divideRule.Type);
Assert.AreEqual(4, divideRule.LeftSideObjects.Count);
Assert.AreEqual("pa", divideRule.LeftSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.LeftSideObjects[1].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[2].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[3].Name);
Assert.AreEqual(2, divideRule.RightSideObjects.Count);
Assert.AreEqual("pa", divideRule.RightSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.RightSideObjects[1].Name);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, divideRule.MRightSideFloatingNames.Count);
}
/// <summary>
/// P system constructor used during simulation.
/// </summary>
/// <param name="mSystemObjects">Deserialized M System objects.</param>
/// <exception cref="ArgumentException">
/// If M System objects objecst list is null.
/// </exception>
public PSystem(DeserializedObjects mSystemObjects)
{
if (mSystemObjects == null)
{
throw new ArgumentException("M System objects can't be null.");
}
SeedTiles = mSystemObjects.SeedTiles;
GlueRadius = mSystemObjects.GlueRadius;
FloatingObjects = new ReadOnlyDictionary <string, FloatingObject>(mSystemObjects.FloatingObjects);
if (FloatingObjects.Any())
{
Mobility = FloatingObjects.Values.Max(obj => obj.Mobility);
}
v_Proteins = new ReadOnlyDictionary <string, Protein>(mSystemObjects.Proteins);
Tiles = new ReadOnlyDictionary <string, Tile>(mSystemObjects.Tiles);
GlueRelation = mSystemObjects.GluePRelation;
v_EvolutionRules = mSystemObjects.EvolutionRules;
//======================================================================
MetabolicRules = new Dictionary <string, IReadOnlyList <EvoMetabolicRule> >();
foreach (string proteinName in v_Proteins.Keys)
{
MetabolicRules[proteinName] = v_EvolutionRules.OfType <EvoMetabolicRule>().Where(rule => proteinName == rule.RProtein.Name).ToList();
}
//======================================================================
CreationRules = new Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> >();
foreach (Glue glue in mSystemObjects.Glues.Values)
{
var creationRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>().Where(rule => rule.Type == EvolutionRule.RuleType.Create).ToList();
CreationRulesPriorities = new SortedSet <int>(creationRules.Select(rule => rule.Priority));
CreationRules[glue] = creationRules.Where(rule => rule.RightSideObjects.OfType <Tile>().Single()
.Connectors.Any(connector => GlueRelation.ContainsKey(Tuple.Create(glue, connector.Glue))))
.ToList();
}
//======================================================================
InsertionRules = new Dictionary <Glue, Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> > >();
foreach (Glue glue1 in mSystemObjects.Glues.Values)
{
foreach (Glue glue2 in mSystemObjects.Glues.Values)
{
var insRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>()
.Where(rule => (rule.Type == EvolutionRule.RuleType.Insert) &&
IsInsertable(rule.RightSideObjects.OfType <Tile>().Single(), glue1, glue2))
.ToList();
if (insRules.Any())
{
AddRulesToDictionary(InsertionRules, glue1, glue2, insRules);
AddRulesToDictionary(InsertionRules, glue2, glue1, insRules);
}
}
}
//======================================================================
DestructionRules = new Dictionary <string, IReadOnlyList <EvoNonMetabolicRule> >();
foreach (string tileName in Tiles.Keys)
{
DestructionRules[tileName] = v_EvolutionRules.OfType <EvoNonMetabolicRule>().Where(rule => (rule.Type == EvolutionRule.RuleType.Destroy) &&
rule.LeftSideObjects.OfType <Tile>().Single().Name == tileName).ToList();
}
//======================================================================
DivisionRules = new Dictionary <Glue, Dictionary <Glue, IReadOnlyList <EvoNonMetabolicRule> > >();
foreach (Glue glue1 in mSystemObjects.Glues.Values)
{
foreach (Glue glue2 in mSystemObjects.Glues.Values)
{
var divRules = v_EvolutionRules.OfType <EvoNonMetabolicRule>()
.Where(rule => (rule.Type == EvolutionRule.RuleType.Divide) &&
glue1 == (Glue)rule.RightSideObjects[0] &&
glue2 == (Glue)rule.RightSideObjects[1])
.ToList();
if (divRules.Any())
{
AddRulesToDictionary(DivisionRules, glue1, glue2, divRules);
AddRulesToDictionary(DivisionRules, glue2, glue1, divRules);
}
}
}
}
public void TestDeserializationCreatesObjectWithCorrectValues()
{
//NOTE: We cannot test equivalence of objects as objects contains readonly parameters, which are never equal.
//Due to this limitation we test only values of parameters.
string path = @"../../Classes/Xml/TestXML/testMSystemDescription.xml";
XDocument mSystemDescription = XDocument.Load(path);
DeserializedObjects testDeserializedObjects = new DeserializedObjects(mSystemDescription, path);
//Floating objects
Dictionary <string, FloatingObject> floatingObjects = testDeserializedObjects.FloatingObjects;
Assert.AreEqual(3, floatingObjects.Count);
Assert.AreEqual("a", floatingObjects["a"].Name);
Assert.AreEqual(0, floatingObjects["a"].Concentration);
Assert.AreEqual(2, floatingObjects["a"].Mobility);
Assert.AreEqual("b", floatingObjects["b"].Name);
Assert.AreEqual(2, floatingObjects["b"].Concentration);
Assert.AreEqual(3, floatingObjects["b"].Mobility);
//Proteins
Dictionary <string, Protein> proteins = testDeserializedObjects.Proteins;
Assert.AreEqual(2, proteins.Count);
Assert.AreEqual("p1", proteins["p1"].Name);
Assert.AreEqual("p2", proteins["p2"].Name);
//Glues
Dictionary <string, Glue> glues = testDeserializedObjects.Glues;
Assert.AreEqual(3, glues.Count);
Assert.AreEqual("pa", glues["pa"].Name);
Assert.AreEqual("pb", glues["pb"].Name);
Assert.AreEqual("px", glues["px"].Name);
//Tiles
Dictionary <string, Tile> tiles = testDeserializedObjects.Tiles;
Assert.AreEqual(3, tiles.Count);
Tile tileQ1 = tiles["q1"];
//Connectors
var connectors = tileQ1.Connectors;
Assert.AreEqual(6, connectors.Count);
var connectorC1 = connectors[0];
Assert.AreEqual("c1", connectorC1.Name);
Assert.AreEqual(Tile.SideType.undef, connectorC1.Side);
Assert.AreEqual(glues["pa"], connectorC1.Glue);
Assert.AreEqual(Angle.FromRadians(2.034443935795703), connectorC1.Angle);
Assert.AreEqual(2, connectorC1.Positions.Count);
Assert.AreEqual(new Point3D(0, 10, 0), connectorC1.Positions[0]);
double posY = 10 * Math.Cos((1) * 2 * Math.PI / 5);
double posX = 10 * Math.Sin((1) * 2 * Math.PI / 5);
Assert.AreEqual(new Point3D(posX, posY, 0), connectorC1.Positions[1]);
//Surface glue
Glue surfaceGLuePx = tileQ1.SurfaceGlue;
Assert.AreEqual("px", surfaceGLuePx.Name);
//Proteins
Assert.AreEqual(4, tileQ1.Proteins.Count);
Assert.AreEqual("p1", tileQ1.Proteins[0].Name);
Assert.AreEqual("p1", tileQ1.Proteins[1].Name);
Assert.AreEqual("p2", tileQ1.Proteins[2].Name);
Assert.AreEqual("p2", tileQ1.Proteins[3].Name);
foreach (var protein in tileQ1.Proteins)
{
Assert.AreEqual(Point3D.Origin, protein.Position);
}
Assert.AreEqual(Color.DeepSkyBlue, tileQ1.Color);
Tile tileS1 = tiles["s1"];
Assert.AreEqual(2, tileS1.Connectors.Count);
Assert.AreEqual(1, tileS1.Proteins.Count);
//Initial objects
List <TileInSpace> seedTiles = testDeserializedObjects.SeedTiles;
Assert.AreEqual(3, seedTiles.Count);
var seedTileQ1 = seedTiles[0];
Assert.AreEqual("q1", seedTileQ1.Name);
Assert.AreEqual(new Point3D(0, 0, 0), seedTileQ1.Position.Round());
Assert.AreEqual(new EulerAngles(default(Angle), default(Angle), default(Angle)), seedTileQ1.Quaternion.ToEulerAngles());
//Others
Assert.AreEqual(0.1, testDeserializedObjects.GlueRadius);
//Glue tuples
GlueRelation glueTuples = testDeserializedObjects.GluePRelation;
Assert.AreEqual(3, glueTuples.Count);
Tuple <Glue, Glue> glueTuplePaPb = glueTuples.Keys.ElementAt(0);
Assert.AreEqual("pa", glueTuplePaPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePaPb.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(0).ToDictionary()["a"]);
Tuple <Glue, Glue> glueTuplePaPa = glueTuples.Keys.ElementAt(1);
Assert.AreEqual("pa", glueTuplePaPa.Item1.Name);
Assert.AreEqual("pa", glueTuplePaPa.Item2.Name);
Assert.AreEqual(1, glueTuples.Values.ElementAt(1).ToDictionary().Count);
Tuple <Glue, Glue> glueTuplePbPb = glueTuples.Keys.ElementAt(2);
Assert.AreEqual("pb", glueTuplePbPb.Item1.Name);
Assert.AreEqual("pb", glueTuplePbPb.Item2.Name);
Assert.AreEqual(0, glueTuples.Values.ElementAt(2).ToDictionary().Count);
//Evo rules
List <EvolutionRule> evoRules = testDeserializedObjects.EvolutionRules;
Assert.AreEqual(4, evoRules.Count);
EvoMetabolicRule metabolicRule = TypeUtil.Cast <EvoMetabolicRule>(evoRules[0]);
Assert.AreEqual(0, metabolicRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Metabolic, metabolicRule.Type);
Assert.AreEqual(EvoMetabolicRule.MetabolicRuleType.Symport, metabolicRule.SubType);
Assert.AreEqual(2, metabolicRule.LeftSideObjects.Count);
Assert.AreEqual("a", metabolicRule.LeftSideObjects[0].Name);
Assert.AreEqual("p1", metabolicRule.LeftSideObjects[1].Name);
Assert.AreEqual(2, metabolicRule.RightSideObjects.Count);
Assert.AreEqual("p1", metabolicRule.RightSideObjects[0].Name);
Assert.AreEqual("a", metabolicRule.RightSideObjects[1].Name);
Assert.AreEqual(0, metabolicRule.MLeftInNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.Count);
Assert.AreEqual(1, metabolicRule.MLeftOutNames.ToDictionary()["a"]);
Assert.AreEqual(1, metabolicRule.MRightInNames.Count);
Assert.AreEqual(1, metabolicRule.MRightInNames.ToDictionary()["a"]);
Assert.AreEqual(0, metabolicRule.MRightOutNames.Count);
Assert.AreEqual("p1", metabolicRule.RProtein.Name);
EvoNonMetabolicRule createRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[1]);
Assert.AreEqual(1, createRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Create, createRule.Type);
Assert.AreEqual(3, createRule.LeftSideObjects.Count);
Assert.AreEqual("a", createRule.LeftSideObjects[0].Name);
Assert.AreEqual("a", createRule.LeftSideObjects[1].Name);
Assert.AreEqual("a", createRule.LeftSideObjects[2].Name);
Assert.AreEqual(1, createRule.RightSideObjects.Count);
Assert.AreEqual("q1", createRule.RightSideObjects[0].Name);
Assert.AreEqual(3, createRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(3, createRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, createRule.MRightSideFloatingNames.Count);
EvoNonMetabolicRule divideRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[2]);
Assert.AreEqual(1, divideRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Divide, divideRule.Type);
Assert.AreEqual(4, divideRule.LeftSideObjects.Count);
Assert.AreEqual("pa", divideRule.LeftSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.LeftSideObjects[1].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[2].Name);
Assert.AreEqual("a", divideRule.LeftSideObjects[3].Name);
Assert.AreEqual(2, divideRule.RightSideObjects.Count);
Assert.AreEqual("pa", divideRule.RightSideObjects[0].Name);
Assert.AreEqual("pa", divideRule.RightSideObjects[1].Name);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, divideRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(0, divideRule.MRightSideFloatingNames.Count);
EvoNonMetabolicRule destroyRule = TypeUtil.Cast <EvoNonMetabolicRule>(evoRules[3]);
Assert.AreEqual(1, destroyRule.Priority);
Assert.AreEqual(EvolutionRule.RuleType.Destroy, destroyRule.Type);
Assert.AreEqual(3, destroyRule.LeftSideObjects.Count);
Assert.AreEqual("a", destroyRule.LeftSideObjects[0].Name);
Assert.AreEqual("a", destroyRule.LeftSideObjects[1].Name);
Assert.AreEqual("s1", destroyRule.LeftSideObjects[2].Name);
Assert.AreEqual(2, destroyRule.RightSideObjects.Count);
Assert.AreEqual("c", destroyRule.RightSideObjects[0].Name);
Assert.AreEqual("c", destroyRule.RightSideObjects[1].Name);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MLeftSideFloatingNames.ToDictionary()["a"]);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.Count);
Assert.AreEqual(2, destroyRule.MRightSideFloatingNames.ToDictionary()["c"]);
}
