static void Main(string[] args)
{
RootEntity root = new RootEntity();
int frameRate = root.GetChild <DataReaderEntity>().GetYAMLObject(@"YAML\ServerConfig.yml").GetData <int>("FrameRate");
int frameMilliseconds = 1000 / frameRate;
Stopwatch stopwatch = new Stopwatch();
int overTime = 0;
while (true)
{
stopwatch.Restart();
root.Step((frameMilliseconds + overTime) * 0.001f);
stopwatch.Stop();
int stepTime = (int)stopwatch.ElapsedMilliseconds;
if (stepTime <= frameMilliseconds)
{
Thread.Sleep(frameMilliseconds - stepTime);
overTime = 0;
}
else
{
overTime = stepTime - frameMilliseconds;
}
}
}
public void StatusUtility_IsModified_WithMultiLevelHirachy_ShouldGetStatus()
{
var rootEntity = new RootEntity();
var leafEntityA = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityA);
var leafEntityB = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityB);
var leafEntityNotNull = new LeafEntity();
rootEntity.LeafEntityNotNull = leafEntityNotNull;
rootEntity.LeafEntityNull = null;
bool unModifiedRoot = StatusManager.IsModified(rootEntity);
rootEntity.Status = EntityStatus.Modified;
bool modifiedRoot = StatusManager.IsModified(rootEntity);
rootEntity.Status = EntityStatus.Unmodified;
leafEntityA.Status = EntityStatus.New;
bool modifiedLeafCollection = StatusManager.IsModified(rootEntity);
leafEntityA.Status = EntityStatus.Unmodified;
leafEntityNotNull.Status = EntityStatus.Deleted;
bool modifiedLeafSubEntity = StatusManager.IsModified(rootEntity);
Assert.IsFalse(unModifiedRoot);
Assert.IsTrue(modifiedRoot);
Assert.IsTrue(modifiedLeafCollection);
Assert.IsTrue(modifiedLeafSubEntity);
}
/// <summary>
/// Chaining method for adding an obstacle to this Section.
/// It initializes bounding boxes and stores in Collidable Obstacles.
/// </summary>
/// <param name="obstacleEntity">The entity containing the obstacle</param>
/// <param name="useSubBoundingBoxes">true to use the bounding boxes of the sub-meshes</param>
/// <returns></returns>
public Section AddObstacleEntity(Entity obstacleEntity, bool useSubBoundingBoxes)
{
// Attach it in ModelEntity
RootEntity.AddChild(obstacleEntity);
// Get and add bb to CollidableObstacles
var modelComponent = obstacleEntity.Get <ModelComponent>();
var collidableObstacle = new Obstacle {
Entity = obstacleEntity
};
if (useSubBoundingBoxes)
{
// Use bounding boxes from parts of the obstacle.
foreach (var mesh in modelComponent.Model.Meshes)
{
collidableObstacle.BoundingBoxes.Add(mesh.BoundingBox);
}
}
else
{
// Use bounding box of the whole model
collidableObstacle.BoundingBoxes.Add(modelComponent.Model.BoundingBox);
}
CollidableObstacles.Add(collidableObstacle);
return(this);
}
public void PatchEmpty_PatchDataBase_WithEmptyDb_ShouldCreateTables_ShouldBeAbleToInsertData()
{
try
{
ITransaction transaction = CreateTransaction();
int id = 36;
RootEntity entity = CreateRootEntityWithoutNullValues(id);
entity.LeafEntities.Add(CreateLeafEntityA(id, 1));
entity.LeafEntities.Add(CreateLeafEntityB(id, 2));
entity.Persist(transaction);
transaction.Commit();
transaction = CreateTransaction();
RootEntity loadedEntity = LoadRootEntityWithId(transaction, id);
transaction.Commit();
AssertTwoRootEntitiesEquals(entity, loadedEntity);
}
catch (System.Exception e)
{
LogManager.GetLogger(typeof(DbGatePatchEmptyDbTests)).Fatal("Exception during test", e);
Assert.Fail(e.Message);
}
}
public TestQuery(RootEntity root)
{
Field(
typeof(RootType),
"root",
"",
new QueryArguments(),
context =>
{
var query = new List <RootEntity> {
root
}.AsQueryable();
return(Resolve.SingleObject <RootEntity, RootDto>(query, context));
});
Field(
typeof(ListGraphType <ChildType>),
"children",
"",
new QueryArguments(),
context =>
{
var query = root.Other.Children.AsQueryable();
return(Resolve.List <ChildEntity, ChildDto>(query, context));
});
}
private RootEntity CreateRootEntityWithoutNullValues(int id)
{
RootEntity entity = new RootEntity();
entity.IdCol = id;
entity.BooleanNotNull = true;
entity.BooleanNull = true;
entity.CharNotNull = 'A';
entity.CharNull = 'B';
entity.DateNotNull = DateTime.Now.AddYears(1);
entity.DateNull = DateTime.Now.AddMonths(1);
entity.DoubleNotNull = 5D;
entity.DoubleNull = 6D;
entity.FloatNotNull = 20F;
entity.FloatNull = 20F;
entity.IntNotNull = 24;
entity.IntNull = 23;
entity.LongNotNull = 356L;
entity.LongNull = 326L;
entity.TimestampNotNull = DateTime.Now.AddHours(1);
entity.TimestampNull = DateTime.Now.AddMinutes(1);
entity.VarcharNotNull = "notNull";
entity.VarcharNull = "null";
return(entity);
}
/// <summary>
/// Applies the impact.
/// </summary>
/// <param name="_direction">Direction.</param>
/// <param name="_force">Force.</param>
/// <param name="_point">Point.</param>
public virtual void ApplyImpact(Vector3 _direction, float _force, Vector3 _point)
{
if (IsChildEntity)
{
RootEntity.ApplyImpact(_direction, _force);
}
else if (ObjectRigidbody != null && !ObjectRigidbody.isKinematic)
{
if (_point == Vector3.zero)
{
ObjectRigidbody.AddForce(_direction.normalized * _force, ForceMode.Impulse);
}
else
{
ObjectRigidbody.AddForceAtPosition(_direction.normalized * _force, _point, ForceMode.Impulse);
}
}
else
{
_direction.Normalize();
if (_direction.y < 0)
{
_direction.y = -_direction.y; // reflect down force on the ground
}
m_ImpactForce += _direction.normalized * _force / Mass;
}
}
public void CreateRootEntity()
{
using (var persistenceContext = PersistenceHelper.CreatePersistenceContext())
{
RootEntity rootEntity = new RootEntity();
rootEntity.Name = "First Root Entity";
rootEntity.SaveOrUpdate();
}
}
public static void Register(RootEntity rpc)
{
rpc.Register(typeof(UIElement), typeof(UIElementFacet));
rpc.Register(typeof(TextBlock), typeof(TextBlockFacet));
rpc.Register(typeof(Button), typeof(ButtonFacet));
rpc.Register(typeof(TreeView), typeof(TreeViewFacet));
rpc.Register(typeof(CheckBox), typeof(CheckBoxFacet));
rpc.Register(typeof(ToggleSwitch), typeof(ToggleSwitchFacet));
rpc.Register(typeof(TextBox), typeof(TextBoxFacet));
}
public Section AddBackgroundEntity(Entity backgroundEntity)
{
// Attach it in ModelEntity
RootEntity.AddChild(backgroundEntity);
// Get length via its bounding box
var modelComponent = backgroundEntity.Get <ModelComponent>().Model;
var boundingBox = modelComponent.BoundingBox;
Length += boundingBox.Maximum.Z - boundingBox.Minimum.Z;
return(this);
}
public void Update(GameTime gameTime)
{
if (!IsActive)
{
return;
}
// Get Delta Time
float dt = (float)gameTime.ElapsedGameTime.TotalSeconds;
// Update
RootEntity.Update(dt);
RootEntity.PostUpdate(dt);
}
public void PatchEmpty_PatchDataBase_WithEmptyDb_ShouldCreatePrimaryKeys_ShouldNotAbleToPutDuplicateData()
{
ITransaction transaction = CreateTransaction();
int id = 37;
RootEntity entity = CreateRootEntityWithoutNullValues(id);
entity.LeafEntities.Add(CreateLeafEntityA(id, 1));
entity.LeafEntities.Add(CreateLeafEntityB(id, 1));
Assert.Throws <PersistException>(() => entity.Persist(transaction));
transaction.Commit();
transaction.Close();
}
public void RootEntity_DeleteExistingChild_StateShould()
{
// Arrange
var root = new RootEntity(new ChildEntity());
Assert.Equal(State.Unchanged, root.State);
Assert.Equal(State.Unchanged, root.ChildEntity.State);
// Act
root.DeleteChildEntity();
// Assert
Assert.Equal(State.Modified, root.State);
Assert.Null(root.ChildEntity);
}
public void RootEntity_UpdateChildProperty_StateShould()
{
// Arrange
var root = new RootEntity(new ChildEntity());
Assert.Equal(State.Unchanged, root.State);
Assert.Equal(State.Unchanged, root.ChildEntity.State);
// Act
root.ChildEntity.SetSimpleField(1);
// Assert
Assert.Equal(State.Unchanged, root.State);
Assert.Equal(State.Modified, root.ChildEntity.State);
}
public void RootEntity_RemoveExistingChild_StateShould()
{
// Arrange
var root = new RootEntity(new ChildEntity());
Assert.Equal(State.Unchanged, root.State);
Assert.Equal(State.Unchanged, root.ChildEntity.State);
// Act
var childEntity = root.ChildEntity;
root.RemoveChildEntity();
// Assert
Assert.Equal(State.Modified, root.State);
Assert.Equal(State.Unchanged, childEntity.State);
Assert.Null(root.ChildEntity);
}
/// <summary>
/// Chaining method for adding an obstacle to this Section.
/// It initializes bounding boxes and stores in Collidable Obstacles.
/// </summary>
/// <param name="obstacleEntity">The entity containing the obstacle</param>
/// <param name="useSubBoundingBoxes">true to use the bounding boxes of the sub-meshes</param>
/// <returns></returns>
public Section AddObstacleEntity(Entity obstacleEntity, bool useSubBoundingBoxes)
{
// Attach it in ModelEntity
RootEntity.AddChild(obstacleEntity);
// Get and add bb to CollidableObstacles
var modelComponent = obstacleEntity.Get <ModelComponent>();
var collidableObstacle = new Obstacle {
Entity = obstacleEntity
};
if (useSubBoundingBoxes)
{
// Use bounding boxes from parts of the obstacle.
foreach (var mesh in modelComponent.Model.Meshes)
{
var boundingBox = mesh.BoundingBox;
var nodeIndex = mesh.NodeIndex;
while (nodeIndex >= 0)
{
var node = modelComponent.Model.Skeleton.Nodes[nodeIndex];
var transform = node.Transform;
var matrix = Matrix.Transformation(Vector3.Zero, Quaternion.Identity, transform.Scale, Vector3.Zero, transform.Rotation, transform.Position);
Vector3.TransformNormal(ref boundingBox.Minimum, ref matrix, out boundingBox.Minimum);
Vector3.TransformNormal(ref boundingBox.Maximum, ref matrix, out boundingBox.Maximum);
nodeIndex = node.ParentIndex;
}
collidableObstacle.BoundingBoxes.Add(boundingBox);
}
}
else
{
// Use bounding box of the whole model
collidableObstacle.BoundingBoxes.Add(modelComponent.Model.BoundingBox);
}
CollidableObstacles.Add(collidableObstacle);
return(this);
}
/// <summary>
/// Adds or forwards the received damage.
/// </summary>
/// <param name="_damage">Damage.</param>
/// <param name="_damage_direction">Damage direction.</param>
/// <param name="_attacker_position">Attacker position.</param>
/// <param name="_attacker">Attacker.</param>
/// <param name="_force">Force.</param>
public virtual void AddDamage(float _damage, Vector3 _damage_direction, Vector3 _damage_position, Transform _attacker, float _force = 0)
{
// use RootEntity instead of m_RootEntity to make sure that the root will be up-to-date
if (IsChildEntity && Status.UseDamageTransfer)
{
RootEntity.AddDamage(_damage * Status.DamageTransferMultiplier, _damage_direction, _damage_position, _attacker, _force);
}
else
{
Status.AddDamage(_damage * Status.DamageTransferMultiplier);
if (OnAddDamage != null)
{
OnAddDamage(_damage * Status.DamageTransferMultiplier, _damage_direction, _damage_position, _attacker, _force);
}
}
//ApplyImpact( _damage_direction, _force );
}
private void AssertTwoRootEntitiesEquals(RootEntity entityA, RootEntity entityB)
{
Assert.AreEqual(entityA.IdCol, entityB.IdCol);
Assert.AreEqual(entityA.CharNotNull, entityB.CharNotNull);
Assert.AreEqual(entityA.CharNull, entityB.CharNull);
Assert.AreEqual(entityA.DateNotNull, entityB.DateNotNull);
Assert.AreEqual(entityA.DateNull, entityB.DateNull);
Assert.AreEqual(entityA.DoubleNotNull, entityB.DoubleNotNull);
Assert.AreEqual(entityA.DoubleNull, entityB.DoubleNull);
Assert.AreEqual(entityA.FloatNotNull, entityB.FloatNotNull);
Assert.AreEqual(entityA.FloatNull, entityB.FloatNull);
Assert.AreEqual(entityA.IntNotNull, entityB.IntNotNull);
Assert.AreEqual(entityA.IntNull, entityB.IntNull);
Assert.AreEqual(entityA.LongNotNull, entityB.LongNotNull);
Assert.AreEqual(entityA.LongNull, entityB.LongNull);
Assert.AreEqual(entityA.TimestampNotNull, entityB.TimestampNotNull);
Assert.AreEqual(entityA.TimestampNull, entityB.TimestampNull);
Assert.AreEqual(entityA.VarcharNotNull, entityB.VarcharNotNull);
Assert.AreEqual(entityA.VarcharNull, entityB.VarcharNull);
Assert.AreEqual(entityA.LeafEntities.Count, entityB.LeafEntities.Count);
IEnumerator <LeafEntity> iteratorA = entityA.LeafEntities.GetEnumerator();
while (iteratorA.MoveNext())
{
LeafEntity leafEntityA = iteratorA.Current;
bool bFound = false;
foreach (LeafEntity leafEntityB in entityB.LeafEntities)
{
if (leafEntityB.IdCol == leafEntityA.IdCol &&
leafEntityB.IndexNo == leafEntityA.IndexNo)
{
bFound = true;
AssertTwoLeafEntitiesTypeAEquals(leafEntityA, leafEntityB);
}
}
if (!bFound)
{
Assert.Fail("Could not found matching leaf entity");
}
}
}
public void ShouldRemoveAssociateWithRequiredAssociateIfRequiredIsNotSet()
{
var targetRequired = new RequiredAssociate();
var sourceRequired = new RequiredAssociate();
var source = new RootEntity();
var target = new RootEntity();
using (var context = new TestDbContext())
{
context.RequiredAssociates.Add(targetRequired);
context.RequiredAssociates.Add(sourceRequired);
context.RootEntities.Add(source);
source.RequiredAssociate = sourceRequired;
context.RootEntities.Add(target);
target.RequiredAssociate = targetRequired;
target.Sources = new List <RootEntity> {
source
};
context.SaveChanges();
}
target.Sources.Remove(source);
int expectedSourceId = source.Id;
int expectedTargetId = target.Id;
int expectedTargetRequiredId = targetRequired.Id;
using (var context = new TestDbContext())
{
context.UpdateGraph(target, map => map.AssociatedCollection(c => c.Sources).AssociatedEntity(c => c.RequiredAssociate));
context.SaveChanges();
Assert.IsNotNull(context.RequiredAssociates.FirstOrDefault(p => p.Id == expectedTargetRequiredId));
Assert.IsNotNull(context.RootEntities.FirstOrDefault(p => p.Id == expectedSourceId));
var targetReloaded = context.RootEntities.Include("Sources").FirstOrDefault(c => c.Id == expectedTargetId);
Assert.IsNotNull(targetReloaded);
Assert.AreEqual(0, targetReloaded.Sources.Count);
}
}
public override void Render()
{
GL.ClearColor(Color.CornflowerBlue);
GL.PointSize(5f);
//GL.Viewport(0, 0, Width, Height);
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
//GL.Enable(EnableCap.LineSmooth); // This is Optional
//GL.Enable(EnableCap.RescaleNormal);
base.Render();
RootEntity.Render();
GL.Flush();
}
public void PatchEmpty_PatchDataBase_WithEmptyDb_ShouldCreateForeignKeys_ShouldNotAbleToInconsistantData()
{
ITransaction transaction = CreateTransaction();
int id = 38;
RootEntity entity = CreateRootEntityWithoutNullValues(id);
entity.Persist(transaction);
var leafEntityA = CreateLeafEntityA(id, 1);
leafEntityA.Persist(transaction);
var leafEntityB = CreateLeafEntityA(id + 1, 1);
Assert.Throws <PersistException>(() => leafEntityB.Persist(transaction));
transaction.Commit();
transaction.Close();
}
public void StatusUtility_SetStatus_WithMultiLevelHirachy_ShouldSetStatus()
{
var rootEntity = new RootEntity();
var leafEntityA = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityA);
var leafEntityB = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityB);
var leafEntityNotNull = new LeafEntity();
rootEntity.LeafEntityNotNull = leafEntityNotNull;
rootEntity.LeafEntityNull = null;
StatusManager.SetStatus(rootEntity, EntityStatus.Modified);
Assert.AreEqual(rootEntity.Status, EntityStatus.Modified);
Assert.AreEqual(leafEntityA.Status, EntityStatus.Modified);
Assert.AreEqual(leafEntityB.Status, EntityStatus.Modified);
Assert.AreEqual(leafEntityNotNull.Status, EntityStatus.Modified);
}
public void ShouldAddTwoAssociatesWithSharedRequiredAssociate()
{
var root = new RootEntity {
RequiredAssociate = new RequiredAssociate(), Sources = new List <RootEntity>()
};
var requiredAssociate = new RequiredAssociate();
var associateOne = new RootEntity {
RequiredAssociate = requiredAssociate
};
var associateTwo = new RootEntity {
RequiredAssociate = requiredAssociate
};
using (var context = new TestDbContext())
{
context.RootEntities.Add(root);
context.RootEntities.Add(associateOne);
context.RootEntities.Add(associateTwo);
context.RequiredAssociates.Add(requiredAssociate);
context.SaveChanges();
} // Simulate detach
var expectedAssociateId = requiredAssociate.Id;
root.Sources.Add(associateOne);
root.Sources.Add(associateTwo);
using (var context = new TestDbContext())
{
root = context.UpdateGraph(root, map => map.AssociatedCollection(r => r.Sources).AssociatedEntity(r => r.RequiredAssociate));
context.SaveChanges();
Assert.IsTrue(root.Sources.All(s => s.RequiredAssociate.Id == expectedAssociateId));
var sourceIds = root.Sources.Select(s => s.Id).ToArray();
var sourcesReloaded = context.RootEntities.Where(r => sourceIds.Contains(r.Id)).ToList();
Assert.IsTrue(sourcesReloaded.All(s => s.RequiredAssociate != null && s.RequiredAssociate.Id == expectedAssociateId));
}
}
public void StatusUtility_GetImmidiateChildrenAndClear_WithMultiLevelHirachy_ShouldGetChildren()
{
var rootEntity = new RootEntity();
var leafEntityA = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityA);
var leafEntityB = new LeafEntity();
rootEntity.LeafEntities.Add(leafEntityB);
var leafEntityNotNull = new LeafEntity();
rootEntity.LeafEntityNotNull = leafEntityNotNull;
rootEntity.LeafEntityNull = null;
ICollection <IClientEntity> childern = StatusManager.GetImmidiateChildrenAndClear(rootEntity);
Assert.IsTrue(childern.Contains(leafEntityA));
Assert.IsTrue(childern.Contains(leafEntityB));
Assert.IsTrue(childern.Contains(leafEntityNotNull));
Assert.IsTrue(rootEntity.LeafEntities.Count == 0);
Assert.IsNull(rootEntity.LeafEntityNotNull);
}
public void RootEntity_AddNewChild_StateShould()
{
// Arrange
var root = new RootEntity();
Assert.Equal(State.Unchanged, root.State);
Assert.Null(root.ChildEntity);
var newChild = new ChildEntity();
Assert.Equal(State.Unchanged, newChild.State);
newChild.Create();
Assert.Equal(State.Added, newChild.State);
// Act
root.SetChildEntity(newChild);
// Assert
Assert.Equal(State.Modified, root.State);
Assert.Equal(State.Added, root.ChildEntity.State);
}
public void ShouldAddAssociatedWithoutChangingRequiredAssociate()
{
var root = new RootEntity {
RequiredAssociate = new RequiredAssociate(), Sources = new List <RootEntity>()
};
var requiredAssociate = new RequiredAssociate();
var owned = new RootEntity {
RequiredAssociate = requiredAssociate
};
using (var context = new TestDbContext())
{
context.RootEntities.Add(root);
context.RootEntities.Add(owned);
context.RequiredAssociates.Add(requiredAssociate);
context.SaveChanges();
} // Simulate detach
var expectedAssociateId = requiredAssociate.Id;
root.Sources.Add(owned);
using (var context = new TestDbContext())
{
root = context.UpdateGraph(root, map => map.AssociatedCollection(r => r.Sources).AssociatedEntity(r => r.RequiredAssociate));
context.SaveChanges();
var ownedAfterSave = root.Sources.FirstOrDefault();
Assert.IsNotNull(ownedAfterSave);
Assert.IsNotNull(ownedAfterSave.RequiredAssociate);
Assert.AreEqual(expectedAssociateId, ownedAfterSave.RequiredAssociate.Id);
var ownedReloaded = context.RootEntities.Single(r => r.Id == ownedAfterSave.Id);
Assert.IsNotNull(ownedReloaded.RequiredAssociate);
Assert.AreEqual(expectedAssociateId, ownedReloaded.RequiredAssociate.Id);
}
}
static async Task <string?> ApplyTemplateAsync(
EntityTemplate template,
EntityTemplateFunctions functions,
TemplateImportState state,
SeqConnection connection,
RootEntity apiRoot,
bool merge)
{
if (!JsonTemplateEvaluator.TryEvaluate(template.Entity, functions.Exports, out var entity, out var error))
{
return(error);
}
var asObject = (IDictionary <string, object>)JsonTemplateObjectGraphConverter.Convert(entity);
// O(Ntemplates) - easy target for optimization with some caching.
var resourceGroupLink = template.ResourceGroup + "Resources";
var link = apiRoot.Links.Single(l => resourceGroupLink.Equals(l.Key, StringComparison.OrdinalIgnoreCase));
var resourceGroup = await connection.Client.GetAsync <ResourceGroup>(apiRoot, link.Key);
if (state.TryGetCreatedEntityId(template.Name, out var existingId) &&
await CheckEntityExistenceAsync(connection, resourceGroup, existingId))
{
asObject["Id"] = existingId;
await UpdateEntityAsync(connection, resourceGroup, asObject, existingId);
Log.Information("Updated existing entity {EntityId} from {TemplateName}", existingId, template.Name);
}
else if (merge && !state.TryGetCreatedEntityId(template.Name, out _) &&
await TryFindMergeTargetAsync(connection, resourceGroup, asObject) is { } mergedId)
{
asObject["Id"] = mergedId;
await UpdateEntityAsync(connection, resourceGroup, asObject, mergedId);
state.AddOrUpdateCreatedEntityId(template.Name, mergedId);
Log.Information("Merged and updated existing entity {EntityId} from {TemplateName}", existingId, template.Name);
}
public void RootEntity_AddExistingChildCollection_StateShould()
{
// Arrange
var root = new RootEntity();
Assert.Equal(State.Unchanged, root.State);
var child = new ChildEntity();
Assert.Equal(State.Unchanged, child.State);
// Act
root.AddChildCollection(child);
Assert.Single(root.ChildCollection);
Assert.Equal(State.Unchanged, root.ChildCollection.FirstOrDefault().State);
root.ChildCollection.Add(new ChildEntity());
Assert.Equal(2, root.ChildCollection.Count);
// Assert
Assert.Equal(State.Modified, root.State);
Assert.Equal(State.Unchanged, root.ChildCollection[0].State);
Assert.Equal(State.Unchanged, root.ChildCollection[1].State);
}
private RootEntity LoadRootEntityWithId(ITransaction transaction, int id)
{
RootEntity loadedEntity = null;
IDbCommand cmd = transaction.CreateCommand();
cmd.CommandText = "select * from root_entity where id_col = ?";
IDbDataParameter parameter = cmd.CreateParameter();
cmd.Parameters.Add(parameter);
parameter.DbType = DbType.Int32;
parameter.Value = id;
IDataReader rs = cmd.ExecuteReader();
if (rs.Read())
{
loadedEntity = new RootEntity();
loadedEntity.Retrieve(rs, transaction);
}
return(loadedEntity);
}
public override void CleanUp()
{
RootEntity.CleanUp();
}
public void Mapping_is_done_recursively()
{
var entity = new RootEntity
{
String = "string 1",
Related = new RelatedEntity
{
Enum = SomeEnum.Value3
},
Children = new[]
{
new ChildEntity()
{
Int = 1,
GrandChildren = null,
},
new ChildEntity()
{
Int = 2,
GrandChildren = new List<GrandChildEntity>()
{
new GrandChildEntity
{
Double = 1.23,
AnotherRelated = new RelatedEntity
{
Enum = SomeEnum.Value2
}
},
new GrandChildEntity
{
Double = 2.34,
AnotherRelated = null
}
}
},
}
};
var rootDto = _mapper.Map<RootDTO>(entity);
Assert.AreEqual("string 1", rootDto.String);
Assert.IsNotNull(rootDto.Related);
Assert.AreEqual(SomeOtherEnum.OtherValue3, rootDto.Related.Enum);
Assert.AreEqual(2, rootDto.Children.Count());
var firstChildDto = rootDto.Children.First();
var secondChildDto = rootDto.Children.Last();
Assert.AreEqual(1, firstChildDto.Int);
Assert.IsNull(firstChildDto.GrandChildren);
Assert.AreEqual(2, secondChildDto.Int);
Assert.IsNotNull(secondChildDto.GrandChildren);
Assert.AreEqual(2, secondChildDto.GrandChildren.Count());
Assert.AreEqual(1.23, secondChildDto.GrandChildren.First().Double);
Assert.IsNotNull(secondChildDto.GrandChildren.First().AnotherRelated);
Assert.AreEqual(SomeOtherEnum.OtherValue2, secondChildDto.GrandChildren.First().AnotherRelated.Enum);
Assert.IsNull(secondChildDto.GrandChildren.Last().AnotherRelated);
Assert.AreEqual(2.34, secondChildDto.GrandChildren.Last().Double);
}
