public void TestMergePropertyContainer()
{
var baseDic = new ObjectWithPropertyContainer();
var newDic = new ObjectWithPropertyContainer();
var newBaseDic = new ObjectWithPropertyContainer()
{
Items = new PropertyContainer()
{
{ DiffComponent.Key, new DiffComponent()
{
Name = "NewComponent"
} },
}
};
var diff = new AssetDiff(AssetCloner.Clone(baseDic), newDic, AssetCloner.Clone(newBaseDic))
{
UseOverrideMode = true
};
var result = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.False(result.HasErrors);
Assert.AreEqual(1, newDic.Items.Count);
}
public void TestChangeOverrideToBaseSealed()
{
var baseAsset = new TestDiffAsset()
{
Name = "Red", Value = 1
};
var newBaseAsset = (TestDiffAsset)AssetCloner.Clone(baseAsset);
newBaseAsset.Value = 3;
var baseItem = new AssetItem("/base", baseAsset);
var childAsset = (TestDiffAsset)baseItem.CreateChildAsset();
// Change base: Name to Base|Sealed
// This should result into a reset of the value overriden in child
// Make New on Name value on first element
var objDesc = TypeDescriptorFactory.Default.Find(typeof(TestDiffAsset));
var memberDesc = objDesc.Members.First(t => t.Name == "Value");
newBaseAsset.SetOverride(memberDesc, OverrideType.Base | OverrideType.Sealed);
var diff = new AssetDiff(baseAsset, childAsset, newBaseAsset)
{
UseOverrideMode = true
};
var diffResult = diff.Compute();
// Check that merged result on Dynamic property is instance from asset2
var mergeResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.AreEqual(3, childAsset.Value); // Value is coming from base
Assert.AreEqual(OverrideType.Base | OverrideType.Sealed, childAsset.GetOverride(memberDesc)); // Value is coming from base
}
void IDiffResolver.BeforeDiff(Asset baseAsset, Asset asset1, Asset asset2)
{
Guid newId;
var baseEntityAsset = (EntityAsset)baseAsset;
var entityAsset1 = (EntityAsset)asset1;
var entityAsset2 = (EntityAsset)asset2;
// Let's remap IDs in asset2 (if it comes from a FBX or such, we need to do that)
var oldBaseTree = new EntityTreeAsset(baseEntityAsset.Hierarchy);
var newBaseTree = new EntityTreeAsset(entityAsset2.Hierarchy);
var idRemapping = new Dictionary <Guid, Guid>();
// Try to transfer ID from old base to new base
var mergeResult = AssetMerge.Merge(oldBaseTree, newBaseTree, oldBaseTree, node =>
{
if (typeof(Guid).IsAssignableFrom(node.InstanceType) && node.BaseNode != null && node.Asset1Node != null)
{
idRemapping.Add((Guid)node.Asset1Node.Instance, (Guid)node.BaseNode.Instance);
}
return(AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1(node));
});
if (mergeResult.HasErrors)
{
//mergeResult.CopyTo();
}
EntityAnalysis.RemapEntitiesId(entityAsset2.Hierarchy, idRemapping);
}
/// <summary>
/// This method is responsible for merging the hierarchy.
/// </summary>
private void MergeHierarchy()
{
if (baseAsset != null && newBaseAsset != null)
{
var diff = new AssetDiff(baseAsset.Hierarchy.RootEntities, newAsset.Hierarchy.RootEntities, newBaseAsset.Hierarchy.RootEntities)
{
UseOverrideMode = true,
};
// Merge collections
var localResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
localResult.CopyTo(result);
}
// Add known entities in hierarchy
var newHierarchy = newAsset.Hierarchy;
// Add entities coming from parts that are roots
newHierarchy.RootEntities.AddRange(rootEntitiesToAdd);
foreach (var rootEntity in newHierarchy.RootEntities)
{
entitiesInHierarchy.Add(rootEntity);
}
// Process hierarchy level by level
// This way, we give higher importance to top levels
var entityIdsToProcess = new List <Guid>(newHierarchy.RootEntities);
while (entityIdsToProcess.Count > 0)
{
entityIdsToProcess = MergeHierarchyByLevel(entityIdsToProcess);
}
}
public void MergeList()
{
var diff = NewTestDiff();
var baseAsset = ((TestDiffAsset)diff.BaseAsset);
var asset1 = ((TestDiffAsset)diff.Asset1);
var asset2 = ((TestDiffAsset)diff.Asset2);
baseAsset.Components.Add(new DiffComponent {
Name = "comp1"
});
asset1.Components.Add(new DiffComponent {
Name = "comp1"
});
asset2.Components.Add(new DiffComponent {
Name = "comp1"
});
asset1.Components.Add(new DiffComponent {
Name = "comp2"
});
var result = AssetMerge.Merge(diff.BaseAsset, diff.Asset1, diff.Asset2, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.IsFalse(result.HasErrors);
var asset = (TestDiffAsset)result.Asset;
Assert.IsNotNull(asset);
Assert.AreEqual(2, asset.Components.Count);
}
/// <summary>
/// Merge an asset with its base, and new base and parts into this instance.
/// </summary>
/// <param name="baseAsset">A copy of the base asset. Can be null if no base asset for newAsset</param>
/// <param name="newBase">A copy of the next base asset. Can be null if no base asset for newAsset.</param>
/// <param name="newBaseParts">A copy of the new base parts</param>
/// <param name="debugLocation">The location of the asset being merged, used only for debug/log purpose</param>
/// <returns>The result of the merge</returns>
/// <remarks>The this instance is not used by this method.</remarks>
public virtual MergeResult Merge(Asset baseAsset, Asset newBase, List <AssetBase> newBaseParts, UFile debugLocation = null)
{
var diff = new AssetDiff(baseAsset, this, newBase)
{
UseOverrideMode = true
};
return(AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1));
}
public void TestListWithIdsChangeType()
{
var baseAsset = new TestDiffAsset()
{
Name = "Red", Value = 1
};
baseAsset.List.Add(new DiffComponent()
{
Name = "Test1", Position = new Vector4(1, 0, 0, 0)
});
baseAsset.List.Add(new DiffComponent()
{
Name = "Test2", Position = new Vector4(1, 0, 0, 0)
});
baseAsset.List.Add(new DiffComponent()
{
Name = "Test3", Position = new Vector4(1, 0, 0, 0)
});
// Change type of 2nd element in newBase list
var newBaseAsset = (TestDiffAsset)AssetCloner.Clone(baseAsset);
newBaseAsset.List[1] = new DiffComponentSub()
{
Value = 1
};
var baseItem = new AssetItem("/base", baseAsset);
var childAsset = (TestDiffAsset)baseItem.CreateChildAsset();
var diff = new AssetDiff(baseAsset, childAsset, newBaseAsset)
{
UseOverrideMode = true
};
var diffResult = diff.Compute();
var diffList = diffResult.Members.First(node => ((DataVisitMember)node.Asset1Node).MemberDescriptor.Name == "List");
// Check that we have only 3 items
Assert.AreEqual(3, diffList.Items.Count);
Assert.AreEqual(Diff3ChangeType.MergeFromAsset2, diffList.Items[1].ChangeType);
var mergeResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.False(mergeResult.HasErrors);
Assert.AreEqual(3, childAsset.List.Count);
Assert.AreEqual("Test1", childAsset.List[0].Name);
Assert.True(childAsset.List[1] is DiffComponentSub);
Assert.AreEqual("Test3", childAsset.List[2].Name);
}
private List <Guid> MergeHierarchyByLevel(List <Guid> entityIds)
{
var nextEntityIds = new List <Guid>();
foreach (var entityId in entityIds)
{
var remap = newEntities[new GroupPartKey(null, entityId)];
var entity = remap.EntityDesign.Entity;
// If we have a base/newbase, we can 3-ways merge lists
if (remap.Base != null && remap.NewBase != null)
{
var diff = new AssetDiff(remap.Base.Children, remap.Children, remap.NewBase.Children)
{
UseOverrideMode = true,
};
// Perform a diff only on the list order but not on the components themselves
diff.CustomVisitorsBase.Add(new SingleLevelVisitor(typeof(TransformComponent), false, -1));
diff.CustomVisitorsAsset1.Add(new SingleLevelVisitor(typeof(TransformComponent), false, -1));
diff.CustomVisitorsAsset2.Add(new SingleLevelVisitor(typeof(TransformComponent), false, -1));
// Merge assets
var localResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
localResult.CopyTo(result);
}
// Popup the children
remap.PopChildren();
// For each child, add them to the list of entities in hierarchy and that we will
// process them in the next round
for (int i = 0; i < entity.Transform.Children.Count; i++)
{
var transformChild = entity.Transform.Children[i];
var subEntityId = transformChild.Entity.Id;
if (entitiesInHierarchy.Add(subEntityId))
{
nextEntityIds.Add(subEntityId);
}
else
{
// The entity was already in the hierarchy, so we remove them from this one.
entity.Transform.Children.RemoveAt(i);
i--;
}
}
}
return(nextEntityIds);
}
public void TestMergeListGuidsWithSwapItems()
{
var item0 = new Guid("9a656db2-d387-4805-a18d-7727d26c0a7a");
var item1 = new Guid("3d22a49d-d891-451f-8e2d-f7cabb11a602");
var item2 = new Guid("3a0c78e7-a961-48ac-870f-3a8cdc6b2c4b");
var newItem = new Guid("481331cc-b3ea-4d48-bdb6-f7741d853eaf");
var baseList = new List <Guid>()
{
item0,
item1,
item2,
};
var asset1List = new List <Guid>()
{
item0,
item1,
item2,
newItem, // new Item from 1
};
var asset2List = new List <Guid>()
{
// new Guid("9a656db2-d387-4805-a18d-7727d26c0a7a"), Item deleted
item2, // Item[2] -> Item[0]
item1, // Item[1] -> Item[1]
};
// Final list must be: item2, item1, newItem
var diff = new AssetDiff(AssetCloner.Clone(baseList), asset1List, AssetCloner.Clone(asset2List))
{
UseOverrideMode = true
};
var result = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.False(result.HasErrors);
Assert.AreEqual(3, asset1List.Count);
Assert.AreEqual(item2, asset1List[0]);
Assert.AreEqual(item1, asset1List[1]);
Assert.AreEqual(newItem, asset1List[2]);
}
public void TestWithNewTypeFromChild()
{
var baseAsset = new TestDiffAsset()
{
Name = "Red", Value = 1, Dynamic = new DiffValueTypeA()
{
Text = "Test1"
}
};
var newBaseAsset = (TestDiffAsset)AssetCloner.Clone(baseAsset);
var baseItem = new AssetItem("/base", baseAsset);
var childAsset = (TestDiffAsset)baseItem.CreateChildAsset();
// Make New on Name value on first element
var objDesc = TypeDescriptorFactory.Default.Find(typeof(TestDiffAsset));
var memberDesc = objDesc.Members.First(t => t.Name == "Dynamic");
childAsset.SetOverride(memberDesc, OverrideType.New); // Override Dynamic and change type
childAsset.Dynamic = new DiffValueTypeB()
{
Value = 2
};
var diff = new AssetDiff(baseAsset, childAsset, newBaseAsset)
{
UseOverrideMode = true
};
var diffResult = diff.Compute();
var diffResultStripped = diffResult.FindLeafDifferences().ToList();
// Check at least one field has merge from asset 1 (Dynamic)
Assert.True(diffResultStripped.Any(node => node.ChangeType == Diff3ChangeType.MergeFromAsset1));
// Check that merged result on Dynamic property is instance from asset2
var mergeResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.True(childAsset.Dynamic is DiffValueTypeB);
Assert.AreEqual(2, ((DiffValueTypeB)childAsset.Dynamic).Value);
}
public void TestMergeDictionaryNewKeyValue()
{
var baseDic = new DictionaryContainer()
{
Items = new Dictionary <string, string>()
{
{ "A", "AValue" },
{ "B", "BValue" },
{ "C", "CValue" },
}
};
var newDic = new DictionaryContainer()
{
Items = new Dictionary <string, string>(baseDic.Items)
};
var newBaseDic = new DictionaryContainer()
{
Items = new Dictionary <string, string>()
{
{ "A", "AValue" },
{ "B", "BValue" },
{ "C", "CValue" },
{ "D", "DValue" },
}
};
var diff = new AssetDiff(AssetCloner.Clone(baseDic), newDic, AssetCloner.Clone(newBaseDic))
{
UseOverrideMode = true
};
var result = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.False(result.HasErrors);
Assert.AreEqual(4, newDic.Items.Count);
}
public void TestWithNewTypeFromNewBase()
{
var baseAsset = new TestDiffAsset()
{
Name = "Red", Value = 1, Dynamic = new DiffValueTypeA()
{
Text = "Test1"
}
};
var newBaseAsset = (TestDiffAsset)AssetCloner.Clone(baseAsset);
newBaseAsset.Dynamic = new DiffValueTypeB()
{
Value = 1
};
var baseItem = new AssetItem("/base", baseAsset);
var childAsset = (TestDiffAsset)baseItem.CreateChildAsset();
var diff = new AssetDiff(baseAsset, childAsset, newBaseAsset)
{
UseOverrideMode = true
};
var diffResult = diff.Compute();
var diffResultStripped = diffResult.FindLeafDifferences().ToList();
// Check that everything is merging from asset2
Assert.True(diffResultStripped.All(node => node.ChangeType == Diff3ChangeType.MergeFromAsset2));
// Check that merged result on Dynamic property is instance from asset2
var mergeResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.True(childAsset.Dynamic is DiffValueTypeB);
Assert.AreEqual(1, ((DiffValueTypeB)childAsset.Dynamic).Value);
}
/// <summary>
/// This method will merge all entities without taking into account hierarchy that will be handled by <see cref="MergeHierarchy"/>
/// </summary>
private void MergeEntities()
{
// Clear all entities
newAsset.Hierarchy.Entities.Clear();
// Visit all existing entities, coming both from newAsset and new entities from newBase
foreach (var entityEntry in newEntities)
{
var entityDesign = entityEntry.Value.EntityDesign;
var newEntity = entityDesign.Entity;
if (entityEntry.Value.Base != null && entityEntry.Value.NewBase != null)
{
var baseRemap = entityEntry.Value.Base;
var newBaseRemap = entityEntry.Value.NewBase;
var baseEntity = baseRemap.EntityDesign.Entity;
var newBaseEntity = newBaseRemap.EntityDesign.Entity;
var diff = new AssetDiff(baseEntity, newEntity, newBaseEntity)
{
UseOverrideMode = true,
};
var previousBaseId = baseEntity.Id;
var previousNewBaseId = newBaseEntity.Id;
// Remap ids to new entity
baseEntity.Id = newEntity.Id;
newBaseEntity.Id = newEntity.Id;
// For entities and components, we will visit only the members of the first level (first entity, or first component)
// but not recursive one (in case a component reference another entity or component)
diff.CustomVisitorsBase.Add(new SingleLevelVisitor(typeof(Entity), false));
diff.CustomVisitorsBase.Add(new SingleLevelVisitor(typeof(EntityComponent), false));
diff.CustomVisitorsAsset1.Add(new SingleLevelVisitor(typeof(Entity), false));
diff.CustomVisitorsAsset1.Add(new SingleLevelVisitor(typeof(EntityComponent), false));
diff.CustomVisitorsAsset2.Add(new SingleLevelVisitor(typeof(Entity), false));
diff.CustomVisitorsAsset2.Add(new SingleLevelVisitor(typeof(EntityComponent), false));
// Merge assets
var localResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
localResult.CopyTo(result);
// Merge folder
// If folder was not changed compare to the base, always take the version coming from the new base, otherwise leave the modified version
if (baseRemap.EntityDesign.Design.Folder == entityDesign.Design.Folder)
{
entityDesign.Design.Folder = newBaseRemap.EntityDesign.Design.Folder;
}
// Restore Ids
baseEntity.Id = previousBaseId;
newBaseEntity.Id = previousNewBaseId;
}
// Add the entity
newAsset.Hierarchy.Entities.Add(entityDesign);
}
}
[Test, Ignore] // ignore the test as long as EntityAsset is not created during import anymore
public void TestImportModelSimple()
{
var file = Path.Combine(Environment.CurrentDirectory, @"scenes\goblin.fbx");
// Create a project with an asset reference a raw file
var project = new Package {
FullPath = Path.Combine(Environment.CurrentDirectory, "ModelAssets", "ModelAssets" + Package.PackageFileExtension)
};
using (var session = new PackageSession(project))
{
var importSession = new AssetImportSession(session);
// ------------------------------------------------------------------
// Step 1: Add files to session
// ------------------------------------------------------------------
importSession.AddFile(file, project, UDirectory.Empty);
// ------------------------------------------------------------------
// Step 2: Stage assets
// ------------------------------------------------------------------
var stageResult = importSession.Stage();
Assert.IsTrue(stageResult);
Assert.AreEqual(0, project.Assets.Count);
// ------------------------------------------------------------------
// Step 3: Import asset directly
// ------------------------------------------------------------------
importSession.Import();
Assert.AreEqual(4, project.Assets.Count);
var assetItem = project.Assets.FirstOrDefault(item => item.Asset is EntityAsset);
Assert.NotNull(assetItem);
EntityAnalysis.UpdateEntityReferences(((EntityAsset)assetItem.Asset).Hierarchy);
var assetCollection = new AssetItemCollection();
// Remove directory from the location
assetCollection.Add(assetItem);
Console.WriteLine(assetCollection.ToText());
//session.Save();
// Create and mount database file system
var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db");
var databaseFileProvider = new DatabaseFileProvider(objDatabase);
AssetManager.GetFileProvider = () => databaseFileProvider;
((EntityAsset)assetItem.Asset).Hierarchy.Entities[0].Components.RemoveWhere(x => x.Key != TransformComponent.Key);
//((EntityAsset)assetItem.Asset).Data.Entities[1].Components.RemoveWhere(x => x.Key != SiliconStudio.Paradox.Engine.TransformComponent.Key);
var assetManager = new AssetManager();
assetManager.Save("Entity1", ((EntityAsset)assetItem.Asset).Hierarchy);
assetManager = new AssetManager();
var entity = assetManager.Load <Entity>("Entity1");
var entity2 = entity.Clone();
var entityAsset = (EntityAsset)assetItem.Asset;
entityAsset.Hierarchy.Entities[0].Components.Add(TransformComponent.Key, new TransformComponent());
var entityAsset2 = (EntityAsset)AssetCloner.Clone(entityAsset);
entityAsset2.Hierarchy.Entities[0].Components.Get(TransformComponent.Key).Position = new Vector3(10.0f, 0.0f, 0.0f);
AssetMerge.Merge(entityAsset, entityAsset2, null, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
}
}
private List <Guid> MergeHierarchyByLevel(List <Guid> entityIds)
{
var nextEntityIds = new List <Guid>();
foreach (var entityId in entityIds)
{
var remap = newEntities[new GroupPartKey(null, entityId)];
var entity = remap.EntityDesign.Entity;
// If we have a base/newbase, we can 3-ways merge lists
if (remap.Base != null)
{
// Build a list of Entities Ids for the BaseEntity.Transform.Children remapped to the new entities (using the BasePartInstanceId of the entity being processed)
var baseChildrenId = new List <Guid>();
var basePartInstanceId = remap.EntityDesign.BasePartInstanceId;
if (remap.Base.Children != null)
{
foreach (var transformComponent in remap.Base.Children)
{
BaseEntityEntry baseEntry;
if (baseEntities.TryGetValue(new GroupPartKey(basePartInstanceId, transformComponent.Entity.Id), out baseEntry) && baseEntry.NewEntity != null)
{
baseChildrenId.Add(baseEntry.NewEntity.EntityDesign.Entity.Id);
}
}
}
// List of Entity ids of the NewEntity.Transform.Children
var currentChildrenIds = new List <Guid>();
if (remap.Children != null)
{
foreach (var transformComponent in remap.Children)
{
currentChildrenIds.Add(transformComponent.Entity.Id);
}
}
// Build a list of Entities Ids for the NewBaseEntity.Transform.Children remapped to the new entities (using the BasePartInstanceId of the entity being processed)
var newBaseChildrenIds = new List <Guid>();
if (remap.NewBase?.Children != null)
{
foreach (var transformComponent in remap.NewBase.Children)
{
BaseEntityEntry baseEntry = null;
if (newBaseEntities.TryGetValue(new GroupPartKey(basePartInstanceId, transformComponent.Entity.Id), out baseEntry) && baseEntry.NewEntity != null)
{
newBaseChildrenIds.Add(baseEntry.NewEntity.EntityDesign.Entity.Id);
}
}
}
// Perform a merge only if it is needed
if (currentChildrenIds.Count > 0 && (baseChildrenId.Count > 0 || newBaseChildrenIds.Count > 0))
{
// Perform a merge of a IDs list
var diff = new AssetDiff(baseChildrenId, currentChildrenIds, newBaseChildrenIds)
{
UseOverrideMode = true,
};
var localResult = AssetMerge.Merge(diff, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
localResult.CopyTo(result);
}
if (remap.Children != null)
{
remap.Children.Clear();
}
foreach (var childId in currentChildrenIds)
{
NewEntityEntry newChildRemap;
if (newEntities.TryGetValue(new GroupPartKey(null, childId), out newChildRemap))
{
if (remap.Children == null)
{
remap.Children = new List <TransformComponent>();
}
remap.Children.Add(newChildRemap.EntityDesign.Entity.Transform);
}
}
}
else if (remap.IsNewBase && remap.Children != null)
{
// If the entity is coming from NewBase, we need to transform the previous children
// to the new one mapped
var children = new List <TransformComponent>(remap.Children);
remap.Children.Clear();
var basePartInstanceId = remap.EntityDesign.BasePartInstanceId;
foreach (var transformComponent in children)
{
BaseEntityEntry baseToNew = null;
if (newBaseEntities.TryGetValue(new GroupPartKey(basePartInstanceId, transformComponent.Entity.Id), out baseToNew) && baseToNew.NewEntity != null)
{
remap.Children.Add(baseToNew.NewEntity.EntityDesign.Entity.Transform);
}
}
}
// Popup the children
remap.PopChildren();
// For each child, add them to the list of entities in hierarchy and that we will
// process them in the next round
for (int i = 0; i < entity.Transform.Children.Count; i++)
{
var transformChild = entity.Transform.Children[i];
var subEntityId = transformChild.Entity.Id;
if (entitiesInHierarchy.Add(subEntityId))
{
nextEntityIds.Add(subEntityId);
}
else
{
// The entity was already in the hierarchy, so we remove them from this one.
entity.Transform.Children.RemoveAt(i);
i--;
}
}
}
return(nextEntityIds);
}
public void MegreWithNoConflict()
{
var diff = NewTestDiff();
var asset1 = ((TestDiffAsset)diff.Asset1);
var asset2 = ((TestDiffAsset)diff.Asset2);
asset1.Value = 2;
asset1.Parameters.Set(ComponentKey, new DiffComponent()
{
Name = "comp1", Position = Vector4.UnitZ
});
asset2.Value = 3;
asset2.Parameters.Set(ComponentKey, new DiffComponent()
{
Name = "comp1", Position = Vector4.UnitY
});
// -----------------------------------
// First merge
// -----------------------------------
var result = AssetMerge.Merge(diff.BaseAsset, diff.Asset1, diff.Asset2, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.IsFalse(result.HasErrors);
var asset = (TestDiffAsset)result.Asset;
Assert.IsNotNull(asset);
// Check merge value: Value is changing (base: 1, v1: 2, v2: 3) but we are assuming that v1 is the actual value
Assert.AreEqual(2, asset.Value);
Assert.IsTrue(asset.Parameters.ContainsKey(ComponentKey));
Assert.AreEqual(new DiffComponent()
{
Name = "comp1", Position = new Vector4(0, 1, 1, 0)
}, asset.Parameters[ComponentKey]); // <= Merge of UnitZ and UnitY => (0, 1, 1, 0)
// -----------------------------------
// 2nd merge : Add a new key and a new item in Asset2
// -----------------------------------
asset2.Parameters.Set(ComponentKey1, new DiffComponent()
{
Name = "newKeyFrom2", Position = Vector4.UnitW
});
asset2.Components.Add(new DiffComponent()
{
Name = "newFrom2", Position = Vector4.UnitX
});
result = AssetMerge.Merge(diff.BaseAsset, asset1, asset2, AssetMergePolicies.MergePolicyAsset2AsNewBaseOfAsset1);
Assert.IsFalse(result.HasErrors);
asset = (TestDiffAsset)result.Asset;
Assert.IsNotNull(asset);
// Check merge values
Assert.AreEqual(2, asset.Value);
Assert.IsTrue(asset.Parameters.ContainsKey(ComponentKey));
Assert.IsTrue(asset.Parameters.ContainsKey(ComponentKey1));
Assert.AreEqual(new DiffComponent()
{
Name = "comp1", Position = new Vector4(0, 1, 1, 0)
}, asset.Parameters[ComponentKey]); // <= Merge of UnitZ and UnitY => (0, 1, 1, 0)
Assert.AreEqual(new DiffComponent()
{
Name = "newKeyFrom2", Position = Vector4.UnitW
}, asset.Parameters[ComponentKey1]);
Assert.AreEqual(1, asset.Components.Count);
Assert.AreEqual(new DiffComponent()
{
Name = "newFrom2", Position = Vector4.UnitX
}, asset.Components[0]);
}
