public void SerializeTilesTest()
{
TileInSpace.ResetCounter();
FloatingObjectInSpace.ResetCounter();
//Set test Floating objects set
FloatingObjectInSpace testFloatingObjectInSpace = new FloatingObjectInSpace(v_TestFloatingObject, new Point3D(0, 0, 0));
FloatingObjectsSet testFloatingObjectsSet = new FloatingObjectsSet {
testFloatingObjectInSpace
};
//Set test Tile set
List <Point3D> testPointList = new List <Point3D>()
{
new Point3D(1, 1, 1), new Point3D(2, 2, 2)
};
Tile baseObject = new Tile("testName", testPointList, null, null, null, Color.Black);
List <TileInSpace> testTilesList = new List <TileInSpace> {
new TileInSpace(baseObject, Point3D.Origin, Quaternion.One)
};
SerializeSnapshot testSnapshot = new SerializeSnapshot(c_TestMSystemDescription, new List <Tile> {
baseObject
});
testSnapshot.Serialize(0, testFloatingObjectsSet, testTilesList);
string serializedSnapShot = testSnapshot.GetXmlDocAsAString();
XDocument expecteDocument = XDocument.Load("../../Classes/Xml/TestXML/serializedSnapShotTest.xml");
//TODO Due to TileInSpace static counter this test fails if you use "run all tests".
Assert.AreEqual(expecteDocument.ToString(), serializedSnapShot); //Compare both documents.
}
/// <summary>
/// Serializes single tile in space.
/// </summary>
/// <param name="tilesNode">Xml node where the tile belongs.</param>
/// <param name="tile">Tile in space</param>
/// <param name="thickness">Tile thickness - relevant only for rods, ignored if <=0</param>
private void SerializeTile(XElement tilesNode, TileInSpace tile, double thickness = 0)
{
/* <tile name="b" objectID="1" state="create">
* <position>
* <posX value="0"/>s
* <posY value="0"/>
* <posZ value="0"/>
* </position>
* <angle>
* <imagX value="0"/>s
* <imagY value="0"/>
* <imagZ value="0"/>
* <real value="0"/>
* </angle>
* <color name = "4000bfff">
* </color>
* </tile> */
XElement tileElement =
new XElement("tile",
new XAttribute("name", tile.Name),
new XAttribute("objectID", tile.ID.ToString()),
new XAttribute("state", tile.State));
SerializePosition(tileElement, tile.Position);
SerializeAngle(tileElement, tile.Quaternion);
SerializeColor(tileElement, tile.Color, tile.Alpha); // Serialize in ARGB, no name
if (thickness > 0)
{
tileElement.Add(new XElement("thickness", new XAttribute("value", thickness.ToString(CultureInfo.InvariantCulture))));
}
tilesNode.Add(tileElement);
}
public void TestConnectObject()
{
TileInSpace baseTile = new TileInSpace(Tile, Point3D.Origin, Quaternion.One);
TileInSpace eastTile = baseTile.Connectors[0].ConnectObject(Tile.Connectors[1]);
TileInSpace southTile = eastTile.Connectors[0].ConnectObject(Tile.Connectors[0]);
TileInSpace topTile = southTile.Connectors[1].ConnectObject(Tile.Connectors[0]);
// Assert.AreEqual(v_ObjInSpace3.Rotations, null); //Debugging
// Assert.AreEqual(v_ObjInSpace3.Quaternion.Print(), null)); // Debugging
var vertices = topTile.Vertices.Select(v => new Point3D(Round(v.X, 10), Round(v.Y, 10), Round(v.Z, 10)));
Assert.AreEqual("(-5, -5, 10),(5, -5, 10),(5, 5, 10),(-5, 5, 10)", string.Join(",", vertices));
TileInSpace verticalTubule = baseTile.Connectors[3].ConnectObject(Tubule.Connectors[0]);
vertices = verticalTubule.Vertices.Select(v => new Point3D(Round(v.X, 10), Round(v.Y, 10), Round(v.Z, 10)));
Assert.AreEqual("(0, 0, 0),(0, 0, -2)", string.Join(",", vertices));
verticalTubule = baseTile.Connectors[2].ConnectObject(Tubule.Connectors[0]);
vertices = verticalTubule.Vertices.Select(v => new Point3D(Round(v.X, 10), Round(v.Y, 10), Round(v.Z, 10)));
Assert.AreEqual("(0, 0, 0),(0, 0, 2)", string.Join(",", vertices));
// TODO add test of connection of a tile to a tubule
TileInSpace slantTubule = verticalTubule.Connectors[1].ConnectObject(Tubule.Connectors[0]);
Assert.AreEqual(2 + 2 * Cos(PI / 6), slantTubule.Vertices[1].Z, MSystem.Tolerance);
}
public void GetObjectsNearProteinTest()
{
TileInSpace.ResetCounter();
FloatingObjectInSpace.ResetCounter();
var testTile = _testTilesWorld.First();
var testProtein = testTile.Proteins.First();
const int count = 20;
int[] results = new int[count];
for (var i = 0; i < count; i++)
{
results[i] = _testFltObjectsWorld.GetNearObjects(testProtein, Tile.SideType.outside, v_InfiniteMultiset).Count;
_testFltObjectsWorld.FinalizeStep();
}
Assert.AreEqual(2500, results.Sum(), 500);
for (var i = 0; i < count; i++)
{
results[i] = _testFltObjectsWorld.GetNearObjects(testProtein, Tile.SideType.inside, v_InfiniteMultiset).Count;
_testFltObjectsWorld.FinalizeStep();
}
Assert.AreEqual(2400, results.Sum(), 500);
//Assert.AreEqual("Result=", string.Join(";", results)); // DEBUGGING
}
public void ColorWasChangedIsFalseWhenSameColorSet()
{
TileInSpace tile = new TileInSpace(CreateSquare("Square"), default(Point3D), Quaternion.One);
Assert.IsFalse(tile.ColorWasChanged);
tile.SetNewColor(tile.Color);
Assert.IsFalse(tile.ColorWasChanged);
}
public void TestConstructor()
{
TileInSpace baseTile = new TileInSpace(Tile, Point3D.Origin, Quaternion.One);
Assert.AreEqual(-90, baseTile.Connectors[3].Angle.Degrees);
Assert.AreEqual(Tile.SideType.outside, baseTile.Connectors[3].Side);
Assert.AreEqual(90, baseTile.Connectors[2].Angle.Degrees);
Assert.AreEqual(Tile.SideType.inside, baseTile.Connectors[2].Side);
}
public void TestPushingIntersected()
{
var testSegment3 = new TileInSpace(CreateSegment("TestSegment3", new Point3D(0, 0, 0), new Point3D(0, 0, 5)), Point3D.Origin, Quaternion.One);
var testSegment4 = new TileInSpace(CreateSegment("TestSegment4", new Point3D(0, -5, -3), new Point3D(0, 5, 3)), Point3D.Origin, Quaternion.One);
var testSegment5 = new TileInSpace(CreateSegment("TestSegment5", new Point3D(0, -10, -3), new Point3D(0, 0, 1)), Point3D.Origin, Quaternion.One);
Assert.AreEqual(default(Vector3D), testSegment3.PushingIntersected(testSegment4, new UnitVector3D(0, 0, -1)));
Assert.AreEqual(default(Vector3D), testSegment3.PushingIntersected(baseTile, new UnitVector3D(0, 0, -1)));
Assert.IsTrue(new Vector3D(0, 0, -3).Equals(testSegment4.PushingIntersected(baseTile, new UnitVector3D(0, 0, -1)), 1e-14));
Assert.IsTrue(new Vector3D(0, 0, -1).Equals(testSegment5.PushingIntersected(baseTile, new UnitVector3D(0, 0, -1)), 1e-14));
}
public void ColorWasChangedIsTrueWhenTwoDifferentColorAreSet()
{
TileInSpace tile = new TileInSpace(CreateSquare("Square"), default(Point3D), Quaternion.One);
Assert.IsFalse(tile.ColorWasChanged);
Color tileColor = tile.Color;
Color newTileColor = Color.Blue;
Assert.AreNotEqual(tileColor, newTileColor);
tile.SetNewColor(newTileColor);
Assert.IsTrue(tile.ColorWasChanged);
}
public void Initialize()
{
_square = CreateSquare("Square");
baseTile = new TileInSpace(_square, default(Point3D), Quaternion.One);
eastTile = baseTile.Connectors[0].ConnectObject(_square.Connectors[1]);
southTile = eastTile.Connectors[0].ConnectObject(_square.Connectors[0]);
topTile = southTile.Connectors[1].ConnectObject(_square.Connectors[0]);
_tubule = CreateSegment("tubule", new Point3D(0, 0, 0), new Point3D(2, 0, 0));
tubule = baseTile.Connectors[2].ConnectObject(_tubule.Connectors[0]);
tubule.Connectors[0].Disconnect();
baseTile.Surface.ConnectTo(tubule.Connectors[0]); // We need to test also component connected by surface glue
}
private void PerformHealthCheck(TileInSpace tile, TileInSpace checkedTile)
{
// do not health check the same object against itself
if (tile.Equals(checkedTile))
{
return;
}
// IDs must not be the same
Assert.AreNotEqual(tile.ID, checkedTile.ID);
// objects must not overlap
//Assert.IsFalse(tile.OverlapsWith(checkedTile));
// XJB DEBUG
if (tile.OverlapsWith(checkedTile))
{
// this shall never happen => get debug strings
string polyI = DumpTileToMathSage(tile, m_colors[0]);
string polyJ = DumpTileToMathSage(checkedTile, m_colors[1]);
string sage = polyI + polyJ + "p" + tile.ID + "+p" + checkedTile.ID;
Assert.IsFalse(true);
}
// objects must not intersect
//Assert.IsFalse(tile.IntersectsWith(checkedTile));
if (tile.IntersectsWith(checkedTile))
{
// this shall never happen => get debug strings
string polyI = DumpTileToMathSage(tile, m_colors[0]);
string polyJ = DumpTileToMathSage(checkedTile, m_colors[1]);
string sage = polyI + polyJ + "p" + tile.ID + "+p" + checkedTile.ID;
// Petr DEBUG
/* tile.Move(-tile.xpushingVector);
* tile.PushingVector = tile.xpushingVector;
* checkedTile.Move(-checkedTile.xpushingVector);
* checkedTile.PushingVector = checkedTile.xpushingVector;
*
* UnitVector3D pushingDirection = TileInSpace.PushingDirection(xConnector.ConnectedTo);
* if (tile == m_tilesWorld.Last())
* tile.PushingIntersected(checkedTile, pushingDirection);
* else if (checkedTile == m_tilesWorld.Last())
* checkedTile.PushingIntersected(tile, pushingDirection);
* else if (tile.xpushingVector.Length > checkedTile.xpushingVector.Length)
* tile.PushingNonIntersected(checkedTile);
* else
* checkedTile.PushingNonIntersected(tile);
*/
Assert.IsFalse(true);
}
}
public void TestBulkAddAndRemove()
{
// XJB DEBUG BEGIN
string rndNumbers = "";
// XJB DEBUG END
// I am duplicating object names here but this way I can control what seed tiles I want to use in the test
string[] objectNames = new string[] { "q1", "q2", "s1" };
// XJB DEBUG BEGIN
//MyRandom rnd = new MyRandom();
MyRandom rnd = new MyRandom(new Random());
// XJB DEBUG END
int count = m_tilesWorld.Count();
// try to add one seed tile to random tile in TilesWorld and perform health check
for (int i = 0; i < 1000; i++)
{
// select randomly TileName => object we will be addiding
int rndSeedTilePos = rnd.Next(objectNames.Length);
string rndSeedTileName = objectNames[rndSeedTilePos];
// get randomly TileInSpace and also its random connector
int rndTilePos = rnd.Next(count);
TileInSpace rndTile = m_tilesWorld.ToList()[rndTilePos];
int rndConnectorPos = rnd.Next(rndTile.Connectors.Count);
var rndConnector = rndTile.Connectors[rndConnectorPos];
// try Add() only if rndConnector is not used yet
if (rndConnector.ConnectedTo == null)
{
if (m_tilesWorld.Add(m_testMSystem.Tiles[rndSeedTileName], rndConnector, out newlyCreatedTile))
{
// XJB DEBUG BEGIN
rndNumbers += rndSeedTilePos + "," + rndTilePos + "," + rndConnectorPos + "\n";
// XJB DEBUG END
Assert.AreEqual(++count, m_tilesWorld.Count());
PerformHealthCheck();
}
else
{
Assert.AreEqual(count, m_tilesWorld.Count());
}
}
}
// XJB DEBUG - mathSage string is there to follow what happened
string mathSage = DumpTilesWorldToSageMath();
}
/// <summary>
/// MSystemStats constructor.
/// </summary>
/// <param name="tilesWorld">Tiles in simulation world</param>
public void CalculateTileStats(TilesWorld tilesWorld)
{
if (tilesWorld == null)
{
throw new ArgumentException("TilesWorld cannot be null.");
}
// get copy of all tiles
HashSet <TileInSpace> polygonTiles = new HashSet <TileInSpace>(tilesWorld.PolygonTiles);
while (polygonTiles.Count != 0)
{
// get first tile in the collection and get its component, e.g. all tiles connected to it
TileInSpace tile = polygonTiles.First();
HashSet <TileInSpace> component = tile.Component();
// now walk through the whole component and count q1 (valued at 1) and q2 (valued at 10) tiles
int completionValue = 0;
foreach (TileInSpace element in component)
{
// only polygon tiles matter
if (element.Vertices is Polygon3D)
{
switch (element.Name)
{
case "q0":
case "q1":
completionValue += 15;
break;
case "q2":
completionValue += 1;
break;
}
}
}
// increment number of components in stats dictionary
if (!m_componentStats.ContainsKey(completionValue))
{
m_componentStats.Add(completionValue, 0);
}
m_componentStats[completionValue]++;
// remove all tiles of the component form the list
foreach (TileInSpace element in component)
{
polygonTiles.Remove(element);
}
}
}
// dump one tile into MathSage format
private string DumpTileToMathSage(TileInSpace tile, string color)
{
string result = "p" + tile.ID + (tile.Vertices.Count == 2 ? " = line([" : " = polygon([");
foreach (var vertex in tile.Vertices)
{
if (tile.Vertices.First() != vertex)
{
result += ",";
}
result += "(" + vertex.X + "," + vertex.Y + "," + vertex.Z + ")";
}
result += "], color = '" + color + "');";
return(result);
}
public void TestConnectToAndDisconnect()
{
Tile testTile1 = CreateSquareTile("test1");
Tile testTile2 = CreateSquareTile("test2");
TileInSpace testTileInSpace1 = new TileInSpace(testTile1, Point3D.Origin, Quaternion.One);
TileInSpace testTileInSpace2 = new TileInSpace(testTile2, Point3D.Origin, Quaternion.One);
ConnectorOnTileInSpace testConnectorOnTile1 = new ConnectorOnTileInSpace(testTileInSpace1, testTileInSpace1.Connectors[0]);
ConnectorOnTileInSpace testConnectorOnTile2 = new ConnectorOnTileInSpace(testTileInSpace2, testTileInSpace2.Connectors[0]);
testConnectorOnTile1.ConnectTo(testConnectorOnTile2);
Assert.IsTrue(testConnectorOnTile1.ConnectedTo == testConnectorOnTile2);
Assert.IsTrue(testConnectorOnTile2.ConnectedTo == testConnectorOnTile1);
testConnectorOnTile1.Disconnect();
Assert.IsNull(testConnectorOnTile1.ConnectedTo);
Assert.IsNull(testConnectorOnTile2.ConnectedTo);
Assert.IsFalse(testConnectorOnTile1.SetDisconnect);
Assert.IsFalse(testConnectorOnTile2.SetDisconnect);
}
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);
}
public void TestAdjacentConnectorsConnected()
{
// create structure on second polygon
Assert.IsTrue(m_tilesWorld.Add(m_testMSystem.Tiles["q1"], m_tilesWorld.ToList()[1].Connectors[0], out newlyCreatedTile));
// - skip Connector[1] - this is the intention
Assert.IsTrue(m_tilesWorld.Add(m_testMSystem.Tiles["q1"], m_tilesWorld.ToList()[1].Connectors[2], out newlyCreatedTile));
PerformHealthCheck();
// the following connectors shall be connected on initial polygon
Assert.IsNotNull(m_tilesWorld.ToList()[1].Connectors[0].ConnectedTo);
Assert.IsNotNull(m_tilesWorld.ToList()[1].Connectors[2].ConnectedTo);
// the following connctors shall NOT be connected on initial polygon
Assert.IsNull(m_tilesWorld.ToList()[1].Connectors[1].ConnectedTo);
Assert.IsNull(m_tilesWorld.ToList()[1].Connectors[3].ConnectedTo);
Assert.IsNull(m_tilesWorld.ToList()[1].Connectors[4].ConnectedTo);
// check connectors on firstly added polygon
TileInSpace foisA = m_tilesWorld.ToList()[3];
Assert.IsNotNull(foisA.Connectors[0].ConnectedTo); // connected to starting polygon
Assert.IsNull(foisA.Connectors[1].ConnectedTo);
Assert.IsNull(foisA.Connectors[2].ConnectedTo);
Assert.IsNull(foisA.Connectors[3].ConnectedTo);
Assert.IsNull(foisA.Connectors[4].ConnectedTo);
Assert.IsNull(foisA.Connectors[5].ConnectedTo);
// check connectors on second added polygon
TileInSpace foisB = m_tilesWorld.ToList()[4];
Assert.IsNotNull(foisB.Connectors[0].ConnectedTo); // connected to starting polygon
Assert.IsNull(foisB.Connectors[1].ConnectedTo);
Assert.IsNull(foisB.Connectors[2].ConnectedTo);
Assert.IsNull(foisB.Connectors[3].ConnectedTo);
Assert.IsNull(foisB.Connectors[4].ConnectedTo);
Assert.IsNull(foisB.Connectors[5].ConnectedTo);
// now add polygon on Connector[1] => in between already added polygons
Assert.IsTrue(m_tilesWorld.Add(m_testMSystem.Tiles["q1"], m_tilesWorld.ToList()[1].Connectors[1], out newlyCreatedTile));
PerformHealthCheck();
// check connectors of all the polygons, adjecent polygons shall connect as well
// the following connectors shall be connected on initial polygon
Assert.IsNotNull(m_tilesWorld.ToList()[1].Connectors[0].ConnectedTo);
Assert.IsNotNull(m_tilesWorld.ToList()[1].Connectors[1].ConnectedTo);
Assert.IsNotNull(m_tilesWorld.ToList()[1].Connectors[2].ConnectedTo);
// the following connctors shall NOT be connected on initial polygon
Assert.IsNull(m_tilesWorld.ToList()[1].Connectors[3].ConnectedTo);
Assert.IsNull(m_tilesWorld.ToList()[1].Connectors[4].ConnectedTo);
// check connectors on firstly added polygon
foisA = m_tilesWorld.ToList()[3];
Assert.IsNotNull(foisA.Connectors[0].ConnectedTo); // connected to starting polygon
Assert.IsNull(foisA.Connectors[1].ConnectedTo);
Assert.IsNull(foisA.Connectors[2].ConnectedTo);
Assert.IsNull(foisA.Connectors[3].ConnectedTo);
Assert.IsNotNull(foisA.Connectors[4].ConnectedTo); // connected to middle polygon
Assert.IsNull(foisA.Connectors[5].ConnectedTo);
// check connectors on second added polygon
foisB = m_tilesWorld.ToList()[4];
Assert.IsNotNull(foisB.Connectors[0].ConnectedTo); // connected to starting polygon
Assert.IsNotNull(foisB.Connectors[1].ConnectedTo); // connected to middle polygon
Assert.IsNull(foisB.Connectors[2].ConnectedTo);
Assert.IsNull(foisB.Connectors[3].ConnectedTo);
Assert.IsNull(foisB.Connectors[4].ConnectedTo);
Assert.IsNull(foisB.Connectors[5].ConnectedTo);
// check connectors on middle polygon
TileInSpace foisMiddle = m_tilesWorld.ToList()[5];
Assert.IsNotNull(foisMiddle.Connectors[0].ConnectedTo); // connected to foisA
Assert.IsNotNull(foisMiddle.Connectors[1].ConnectedTo); // connected to starting polygon
Assert.IsNotNull(foisMiddle.Connectors[2].ConnectedTo); // connected to foisB
Assert.IsNull(foisMiddle.Connectors[3].ConnectedTo);
Assert.IsNull(foisMiddle.Connectors[4].ConnectedTo);
Assert.IsNull(foisMiddle.Connectors[5].ConnectedTo);
}
public void CreateComplexSnapshotFileTest()
// Petr: Actually not a test - only temporary debugging method. Please do not remove.
// Produces a test snapshot file for Honza - testing the visualization package in Unity.
{
//Set test Floating objects set
var testFloatingObjectInSpace = new FloatingObjectInSpace(v_TestFloatingObject, new Point3D(0, 1, 2)); // Add more
var testFloatingObjectsSet = new FloatingObjectsSet {
testFloatingObjectInSpace
};
Tile baseTile = CreateTile("q2");
Tile baseTubule = CreateSegment("s1");
var v_baseTilesList = new List <Tile> {
baseTile, baseTubule
};
var testTilesList = new List <TileInSpace>
{
new TileInSpace(baseTile, Point3D.Origin, Quaternion.One)
};
SerializeSnapshot testSnapshot = new SerializeSnapshot(c_TestMSystemDescription, v_baseTilesList);
testSnapshot.Serialize(0, testFloatingObjectsSet, testTilesList);
TileInSpace bottomTile = testTilesList.First();
bottomTile.State = TileInSpace.FState.Unchanged;
var level1Tiles = new List <TileInSpace>();
for (int i = 0; i < 5; i++)
{
level1Tiles.Add(bottomTile.Connectors[i].ConnectObject(baseTile.Connectors[0]));
}
testTilesList.AddRange(level1Tiles);
var tubule1 = bottomTile.Connectors.Last().ConnectObject(baseTubule.Connectors[0]);
testTilesList.Add(tubule1);
testSnapshot.Serialize(1, testFloatingObjectsSet, testTilesList);
// Adding the second level of tiles of dodecahedron and tubules
tubule1.State = TileInSpace.FState.Unchanged;
var level2Tiles = new List <TileInSpace>();
var level2Tubules = new List <TileInSpace>();
foreach (var tile in level1Tiles)
{
tile.State = TileInSpace.FState.Unchanged;
level2Tiles.Add(tile.Connectors[2].ConnectObject(baseTile.Connectors[0]));
}
for (int i = 1; i < 3; i++)
{
level2Tubules.Add(tubule1.Connectors[i].ConnectObject(baseTubule.Connectors[0]));
}
testTilesList.AddRange(level2Tiles);
testTilesList.AddRange(level2Tubules);
testSnapshot.Serialize(2, testFloatingObjectsSet, testTilesList);
foreach (var tile in level2Tiles)
{
tile.State = TileInSpace.FState.Unchanged;
}
// Adding the last top tile of dodecahedron
TileInSpace topTile = level2Tiles.Last().Connectors[3].ConnectObject(baseTile.Connectors[0]);
testTilesList.Add(topTile);
var level3Tubules = new List <TileInSpace>();
foreach (var tubule in level2Tubules)
{
tubule.State = TileInSpace.FState.Unchanged;
for (int i = 1; i < 3; i++)
{
level3Tubules.Add(tubule.Connectors[i].ConnectObject(baseTubule.Connectors[0]));
}
}
// Dodecahedron complete, three levels of tubule tree complete
testTilesList.AddRange(level3Tubules);
testSnapshot.Serialize(3, testFloatingObjectsSet, testTilesList);
topTile.State = TileInSpace.FState.Unchanged;
foreach (var tubule in level3Tubules)
{
tubule.State = TileInSpace.FState.Unchanged;
}
foreach (var tile in level2Tiles)
{
tile.State = TileInSpace.FState.Destroy;
}
// Level 2 tiles destructed
testSnapshot.Serialize(4, testFloatingObjectsSet, testTilesList);
testTilesList.RemoveAll(obj => level2Tiles.Contains(obj));
topTile.Move(new Vector3D(0, 0, -5));
// Top tile moved 5 units down
testSnapshot.Serialize(5, testFloatingObjectsSet, testTilesList);
topTile.State = TileInSpace.FState.Unchanged;
var Tile = CreateSquareTile("TestSquare");
TileInSpace baseSquare = new TileInSpace(Tile, new Point3D(30, 0, 0), Quaternion.One);
TileInSpace eastSquare = baseSquare.Connectors[0].ConnectObject(Tile.Connectors[1]);
TileInSpace southSquare = eastSquare.Connectors[0].ConnectObject(Tile.Connectors[0]);
TileInSpace topSquare = southSquare.Connectors[1].ConnectObject(Tile.Connectors[0]);
// Four squares added, forming an incomplete cube
testTilesList.AddRange(new List <TileInSpace>()
{
baseSquare, eastSquare, southSquare, topSquare
});
testSnapshot.Serialize(6, testFloatingObjectsSet, testTilesList);
testSnapshot.SaveXmlFile(@"..\..\..\Cytos_v2\Examples\TestSnapshotFile.xml");
}
