public void TestWithIncorrectObjectReferences()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObject1:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
MyObject2: ref!! 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
MyObject1:
Value: MyModifiedInstance
Id: 00000003-0003-0000-0300-000003000000
MyObject2: ref!! 00000004-0004-0000-0400-000004000000
MyObject3:
Value: MyModifiedInstance
Id: 00000004-0004-0000-0400-000004000000
";
Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) => (targetNode as IMemberNode)?.Name == nameof(Types.MyAssetWithRef.MyObject2);
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var prevInstance = context.DerivedAsset.MyObject2;
Assert.NotEqual(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObject2);
context.DerivedGraph.ReconcileWithBase();
Assert.NotEqual(prevInstance, context.DerivedAsset.MyObject2);
Assert.NotEqual(context.BaseAsset.MyObject1, context.DerivedAsset.MyObject1);
Assert.NotEqual(context.BaseAsset.MyObject2, context.DerivedAsset.MyObject2);
Assert.Equal(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObject2);
Assert.Null(context.DerivedAsset.MyObject3);
}
public void TestWithInvalidObjectReferencesAndMissingTargetInList()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObject1:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
MyObjects:
0a0000000a0000000a0000000a000000: ref!! 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
MyObject1: null
MyObjects:
0a0000000a0000000a0000000a000000: ref!! 00000002-0002-0000-0200-000002000000
";
Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) => (targetNode as IObjectNode)?.ItemReferences != null;
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var prevInstance = context.DerivedAsset.MyObjects[0];
context.DerivedGraph.ReconcileWithBase();
Assert.NotEqual(prevInstance, context.DerivedAsset.MyObjects[0]);
Assert.NotEqual(context.BaseAsset.MyObject1, context.DerivedAsset.MyObject1);
Assert.NotEqual(context.BaseAsset.MyObjects[0], context.DerivedAsset.MyObjects[0]);
Assert.NotNull(context.DerivedAsset.MyObject1);
Assert.Equal(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObjects[0]);
}
public void TestPrimitiveMember()
{
const string primitiveMemberBaseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset1,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyString: MyBaseString
";
const string primitiveMemberOverridenYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset1,Stride.Core.Assets.Quantum.Tests
Id: 30000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyString*: MyDerivedString
";
const string primitiveMemberToReconcileYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset1,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyString: MyDerivedString
";
var context = DeriveAssetTest <Types.MyAsset1, Types.MyAssetBasePropertyGraph> .LoadFromYaml(primitiveMemberBaseYaml, primitiveMemberOverridenYaml);
Assert.Equal("MyBaseString", context.BaseAsset.MyString);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyString);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal("MyBaseString", context.BaseAsset.MyString);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyString);
context = DeriveAssetTest <Types.MyAsset1, Types.MyAssetBasePropertyGraph> .LoadFromYaml(primitiveMemberBaseYaml, primitiveMemberToReconcileYaml);
Assert.Equal("MyBaseString", context.BaseAsset.MyString);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyString);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal("MyBaseString", context.BaseAsset.MyString);
Assert.Equal("MyBaseString", context.DerivedAsset.MyString);
}
public void TestWithCorrectObjectReferencesInList()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObject1:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
MyObjects:
0a0000000a0000000a0000000a000000: ref!! 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
MyObject1:
Value: MyInstance
Id: 00000003-0003-0000-0300-000003000000
MyObjects:
0a0000000a0000000a0000000a000000: ref!! 00000003-0003-0000-0300-000003000000
";
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var prevInstance = context.DerivedAsset.MyObjects[0];
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(GuidGenerator.Get(2), context.BaseAsset.MyObject1.Id);
Assert.Equal(context.BaseAsset.MyObject1, context.BaseAsset.MyObjects[0]);
Assert.Equal(GuidGenerator.Get(3), context.DerivedAsset.MyObject1.Id);
Assert.Equal(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObjects[0]);
Assert.Equal(prevInstance, context.DerivedAsset.MyObjects[0]);
}
public static DeriveAssetTest <TAsset, TAssetPropertyGraph> DeriveAsset(TAsset baseAsset, bool deriveTwice = true)
{
var container = new AssetPropertyGraphContainer(new AssetNodeContainer {
NodeBuilder = { NodeFactory = new AssetNodeFactory() }
});
var baseContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, baseAsset);
baseContainer.BuildGraph();
var derivedAsset = (TAsset)baseContainer.Asset.CreateDerivedAsset("MyAsset");
var derivedContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(baseContainer.Container, derivedAsset);
derivedContainer.BuildGraph();
derivedContainer.Graph.RefreshBase();
AssetTestContainer <TAsset, TAssetPropertyGraph> subDerivedContainer = null;
if (deriveTwice)
{
var subDerivedAsset = (TAsset)derivedContainer.Asset.CreateDerivedAsset("MySubAsset");
subDerivedContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(baseContainer.Container, subDerivedAsset);
subDerivedContainer.BuildGraph();
subDerivedContainer.Graph.RefreshBase();
}
var result = new DeriveAssetTest <TAsset, TAssetPropertyGraph>(baseContainer, derivedContainer, subDerivedContainer);
return(result);
}
public void TestAllMissingInList()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObjects:
0a0000000a0000000a0000000a000000:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
0a0000000b0000000b0000000b000000: ref!! 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
";
Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) => index.IsInt && index.Int == 1;
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(GuidGenerator.Get(2), context.BaseAsset.MyObjects[0].Id);
Assert.Equal(context.BaseAsset.MyObjects[1], context.BaseAsset.MyObjects[0]);
Assert.Equal(2, context.DerivedAsset.MyObjects.Count);
Assert.NotEqual(GuidGenerator.Get(2), context.DerivedAsset.MyObjects[0].Id);
Assert.Equal(context.DerivedAsset.MyObjects[1], context.DerivedAsset.MyObjects[0]);
}
public void TestAddBaseRemoveDerivedAndAddInBaseWithSubDerived()
{
var asset = new Types.MyAsset2 {
MyStrings = { "String1", "String2" }
};
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
var subDerivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.SubDerivedAsset.MyStrings);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var subDerivedPropertyNode = context.SubDerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
// Delete an item from the derived and then update the same from the base
basePropertyNode.Target.Add("String3");
var derivedDeletedId = derivedIds[2];
derivedPropertyNode.Target.Remove("String3", new NodeIndex(2));
basePropertyNode.Target.Add("String4");
Assert.Equal(4, context.BaseAsset.MyStrings.Count);
Assert.Equal(3, context.DerivedAsset.MyStrings.Count);
Assert.Equal(3, context.SubDerivedAsset.MyStrings.Count);
Assert.Equal("String1", basePropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", basePropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String3", basePropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal("String4", basePropertyNode.Retrieve(new NodeIndex(3)));
Assert.Equal("String1", derivedPropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", derivedPropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String4", derivedPropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal("String1", subDerivedPropertyNode.Retrieve(new NodeIndex(0)));
Assert.Equal("String2", subDerivedPropertyNode.Retrieve(new NodeIndex(1)));
Assert.Equal("String4", subDerivedPropertyNode.Retrieve(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, basePropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex(3)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(0)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(1)));
Assert.Equal(OverrideType.Base, subDerivedPropertyNode.Target.GetItemOverride(new NodeIndex(2)));
Assert.Equal(4, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(1, derivedIds.DeletedCount);
Assert.Equal(3, subDerivedIds.KeyCount);
Assert.Equal(0, subDerivedIds.DeletedCount);
Assert.Equal(baseIds[0], derivedIds[0]);
Assert.Equal(baseIds[1], derivedIds[1]);
Assert.Equal(baseIds[3], derivedIds[2]);
Assert.Equal(derivedIds[0], subDerivedIds[0]);
Assert.Equal(derivedIds[1], subDerivedIds[1]);
Assert.Equal(derivedIds[2], subDerivedIds[2]);
Assert.True(derivedIds.IsDeleted(derivedDeletedId));
}
public void TestDictionaryAddedKeyInBase()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
15000000150000001500000015000000~Key2.5: String2.5
14000000140000001400000014000000~Key2: String2
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
14000000140000001400000014000000~Key2: String2
";
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
Assert.Equal(3, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String2.5", context.BaseAsset.MyDictionary["Key2.5"]);
Assert.Equal("String2", context.BaseAsset.MyDictionary["Key2"]);
Assert.Equal(2, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.Equal(3, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(21), baseIds["Key2.5"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key2"]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key2"]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(3, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String2.5", context.BaseAsset.MyDictionary["Key2.5"]);
Assert.Equal("String2", context.BaseAsset.MyDictionary["Key2"]);
Assert.Equal(3, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2.5", context.DerivedAsset.MyDictionary["Key2.5"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.Equal(3, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(21), baseIds["Key2.5"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key2"]);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(21), derivedIds["Key2.5"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key2"]);
}
public void TestCollectionRemovedItemFromBase()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset2,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000: String1
14000000140000001400000014000000: String3
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset2,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
Struct:
MyStrings: {}
MyStrings:
0a0000000a0000000a0000000a000000: String1
24000000240000002400000024000000: String2
14000000140000001400000014000000: String3
";
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
Assert.Equal(2, context.BaseAsset.MyStrings.Count);
Assert.Equal("String1", context.BaseAsset.MyStrings[0]);
Assert.Equal("String3", context.BaseAsset.MyStrings[1]);
Assert.Equal(3, context.DerivedAsset.MyStrings.Count);
Assert.Equal("String1", context.DerivedAsset.MyStrings[0]);
Assert.Equal("String2", context.DerivedAsset.MyStrings[1]);
Assert.Equal("String3", context.DerivedAsset.MyStrings[2]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds[1]);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds[1]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds[2]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(2, context.BaseAsset.MyStrings.Count);
Assert.Equal("String1", context.BaseAsset.MyStrings[0]);
Assert.Equal("String3", context.BaseAsset.MyStrings[1]);
Assert.Equal(2, context.DerivedAsset.MyStrings.Count);
Assert.Equal("String1", context.DerivedAsset.MyStrings[0]);
Assert.Equal("String3", context.DerivedAsset.MyStrings[1]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds[1]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds[0]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds[1]);
}
public void TestDictionaryRemovedDeletedItemFromBase()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
24000000240000002400000024000000~Key3: String3
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
24000000240000002400000024000000~Key3: String2
14000000140000001400000014000000~: ~(Deleted)
";
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
Assert.Equal(2, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3"]);
Assert.Equal(2, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key3"]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), baseIds["Key3"]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(1, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds["Key3"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds.DeletedItems.Single());
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(2, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3"]);
Assert.Equal(2, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String3", context.DerivedAsset.MyDictionary["Key3"]);
Assert.Equal(2, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), baseIds["Key3"]);
Assert.Equal(2, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds["Key3"]);
}
public void TestSimpleDictionaryRemoveDeleted()
{
var asset = new Types.MyAsset3 {
MyDictionary = { { "Key1", "String1" }, { "Key2", "String2" }, { "Key3", "String3" }, { "Key4", "String4" } }
};
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset3.MyDictionary)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset3.MyDictionary)];
// Delete an item from the derived and then delete the same from the base
var derivedDeletedId = derivedIds["Key3"];
derivedPropertyNode.Target.Remove("String3", new NodeIndex("Key3"));
var baseDeletedId = baseIds["Key3"];
basePropertyNode.Target.Remove("String3", new NodeIndex("Key3"));
Assert.Equal(3, context.BaseAsset.MyDictionary.Count);
Assert.Equal(3, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", basePropertyNode.Retrieve(new NodeIndex("Key1")));
Assert.Equal("String2", basePropertyNode.Retrieve(new NodeIndex("Key2")));
Assert.Equal("String4", basePropertyNode.Retrieve(new NodeIndex("Key4")));
Assert.Equal("String1", derivedPropertyNode.Retrieve(new NodeIndex("Key1")));
Assert.Equal("String2", derivedPropertyNode.Retrieve(new NodeIndex("Key2")));
Assert.Equal("String4", derivedPropertyNode.Retrieve(new NodeIndex("Key4")));
Assert.Equal(OverrideType.Base, basePropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key1")));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key2")));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key4")));
Assert.Equal(OverrideType.Base, derivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key1")));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key2")));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key4")));
Assert.Equal(3, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(baseIds["Key1"], derivedIds["Key1"]);
Assert.Equal(baseIds["Key2"], derivedIds["Key2"]);
Assert.Equal(baseIds["Key4"], derivedIds["Key4"]);
Assert.False(derivedIds.IsDeleted(derivedDeletedId));
Assert.False(baseIds.IsDeleted(baseDeletedId));
}
public void TestSimpleCollectionRemoveDeleted()
{
var asset = new Types.MyAsset2 {
MyStrings = { "String1", "String2", "String3", "String4" }
};
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
// Delete an item from the derived and then delete the same from the base
var derivedDeletedId = derivedIds[2];
var baseDeletedId = baseIds[2];
derivedPropertyNode.Target.Remove("String3", new Index(2));
basePropertyNode.Target.Remove("String3", new Index(2));
Assert.Equal(3, context.BaseAsset.MyStrings.Count);
Assert.Equal(3, context.DerivedAsset.MyStrings.Count);
Assert.Equal("String1", basePropertyNode.Retrieve(new Index(0)));
Assert.Equal("String2", basePropertyNode.Retrieve(new Index(1)));
Assert.Equal("String4", basePropertyNode.Retrieve(new Index(2)));
Assert.Equal("String1", derivedPropertyNode.Retrieve(new Index(0)));
Assert.Equal("String2", derivedPropertyNode.Retrieve(new Index(1)));
Assert.Equal("String4", derivedPropertyNode.Retrieve(new Index(2)));
Assert.Equal(OverrideType.Base, basePropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new Index(0)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new Index(1)));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new Index(2)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new Index(0)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new Index(1)));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new Index(2)));
Assert.Equal(3, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(baseIds[0], derivedIds[0]);
Assert.Equal(baseIds[1], derivedIds[1]);
Assert.Equal(baseIds[2], derivedIds[2]);
Assert.False(derivedIds.IsDeleted(derivedDeletedId));
Assert.False(baseIds.IsDeleted(baseDeletedId));
}
public void TestSimpleDictionaryAddWithCollision()
{
var asset = new Types.MyAsset3 {
MyDictionary = { { "Key1", "String1" }, { "Key2", "String2" } }
};
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset3.MyDictionary)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset3.MyDictionary)];
// Update a key to derived and then the same key to the base
derivedPropertyNode.Target.Add("String3", new NodeIndex("Key3"));
basePropertyNode.Target.Add("String4", new NodeIndex("Key3"));
Assert.Equal(3, context.BaseAsset.MyDictionary.Count);
Assert.Equal(3, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", basePropertyNode.Retrieve(new NodeIndex("Key1")));
Assert.Equal("String2", basePropertyNode.Retrieve(new NodeIndex("Key2")));
Assert.Equal("String4", basePropertyNode.Retrieve(new NodeIndex("Key3")));
Assert.Equal("String1", derivedPropertyNode.Retrieve(new NodeIndex("Key1")));
Assert.Equal("String2", derivedPropertyNode.Retrieve(new NodeIndex("Key2")));
Assert.Equal("String3", derivedPropertyNode.Retrieve(new NodeIndex("Key3")));
Assert.Equal(OverrideType.Base, basePropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key1")));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key2")));
Assert.Equal(OverrideType.Base, basePropertyNode.Target.GetItemOverride(new NodeIndex("Key3")));
Assert.Equal(OverrideType.Base, derivedPropertyNode.GetContentOverride());
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key1")));
Assert.Equal(OverrideType.Base, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key2")));
Assert.Equal(OverrideType.New, derivedPropertyNode.Target.GetItemOverride(new NodeIndex("Key3")));
Assert.NotEqual(baseIds, derivedIds);
Assert.Equal(3, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(3, derivedIds.KeyCount);
Assert.Equal(1, derivedIds.DeletedCount);
Assert.Equal(baseIds["Key1"], derivedIds["Key1"]);
Assert.Equal(baseIds["Key2"], derivedIds["Key2"]);
Assert.NotEqual(baseIds["Key3"], derivedIds["Key3"]);
Assert.Equal(baseIds["Key3"], derivedIds.DeletedItems.Single());
Assert.Equal(3, context.BaseAsset.MyDictionary.Count);
Assert.Equal(3, context.DerivedAsset.MyDictionary.Count);
}
public static DeriveAssetTest <TAsset, TAssetPropertyGraph> LoadFromYaml(string baseYaml, string derivedYaml)
{
var container = new AssetPropertyGraphContainer(new AssetNodeContainer {
NodeBuilder = { NodeFactory = new AssetNodeFactory() }
});
var baseAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(baseYaml), $"MyAsset{Types.FileExtension}");
var derivedAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(derivedYaml), $"MyDerivedAsset{Types.FileExtension}");
var baseContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, baseAsset.Asset);
var derivedContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, derivedAsset.Asset);
baseAsset.YamlMetadata.CopyInto(baseContainer.AssetItem.YamlMetadata);
derivedAsset.YamlMetadata.CopyInto(derivedContainer.AssetItem.YamlMetadata);
baseContainer.BuildGraph();
derivedContainer.BuildGraph();
var result = new DeriveAssetTest <TAsset, TAssetPropertyGraph>(baseContainer, derivedContainer, null);
derivedContainer.Graph.RefreshBase();
return(result);
}
public void TestWithOverriddenObjectReferencesInList()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObject1:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
MyObject2:
Value: MyInstance
Id: 00000003-0003-0003-0300-000003000000
MyObjects:
0a0000000a0000000a0000000a000000: ref!! 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
MyObject1:
Value: MyModifiedInstance
Id: 00000003-0003-0003-0300-000003000000
MyObject2:
Value: MyInstance
Id: 00000004-0004-0000-0400-000004000000
MyObjects:
0a0000000a0000000a0000000a000000*: ref!! 00000004-0004-0000-0400-000004000000
";
Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) => (targetNode as IObjectNode)?.ItemReferences != null;
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var prevInstance = context.DerivedAsset.MyObjects[0];
Assert.Equal(context.DerivedAsset.MyObject2, context.DerivedAsset.MyObjects[0]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(prevInstance, context.DerivedAsset.MyObjects[0]);
Assert.NotEqual(context.BaseAsset.MyObject1, context.DerivedAsset.MyObject1);
Assert.NotEqual(context.BaseAsset.MyObjects[0], context.DerivedAsset.MyObjects[0]);
Assert.NotEqual(context.BaseAsset.MyObject2, context.DerivedAsset.MyObject2);
Assert.NotEqual(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObjects[0]);
Assert.Equal(context.DerivedAsset.MyObject2, context.DerivedAsset.MyObjects[0]);
Assert.Equal(GuidGenerator.Get(4), context.DerivedAsset.MyObject2.Id);
}
public void TestCollectionObjectReferenceGraph()
{
var obj = new Types.MyReferenceable {
Id = GuidGenerator.Get(2), Value = "MyInstance"
};
var asset = new Types.MyAssetWithRef2 {
NonReference = obj, References = { obj }
};
var context = DeriveAssetTest <Types.MyAssetWithRef2, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
Assert.Equal(Types.MyAssetWithRef2.MemberCount, context.BaseGraph.RootNode.Members.Count);
Assert.True(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.NonReference)].IsReference);
Assert.Equal(obj, context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.NonReference)].Target.Retrieve());
Assert.True(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].IsReference);
Assert.Equal(obj, context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].Target.Retrieve(new Index(0)));
Assert.Equal(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.NonReference)].Target, context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].Target.IndexedTarget(new Index(0)));
Assert.Equal(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.References)], context.DerivedGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].BaseNode);
Assert.Equal(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].Target, context.DerivedGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].Target.BaseNode);
Assert.Equal(context.BaseGraph.RootNode[nameof(Types.MyAssetWithRef2.NonReference)].Target, context.DerivedGraph.RootNode[nameof(Types.MyAssetWithRef2.References)].Target.IndexedTarget(new Index(0)).BaseNode);
}
public void TestAllMissingInvertOrder()
{
const string baseYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 00000001-0001-0000-0100-000001000000
MyObject1: ref!! 00000002-0002-0000-0200-000002000000
MyObject2:
Value: MyInstance
Id: 00000002-0002-0000-0200-000002000000
";
const string derivedYaml = @"!Stride.Core.Assets.Quantum.Tests.Helpers.Types+MyAssetWithRef,Stride.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 00000001-0001-0000-0100-000001000000:MyAsset
";
Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) => (targetNode as IMemberNode)?.Name == nameof(Types.MyAssetWithRef.MyObject1);
var context = DeriveAssetTest <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(GuidGenerator.Get(2), context.BaseAsset.MyObject1.Id);
Assert.Equal(context.BaseAsset.MyObject1, context.BaseAsset.MyObject2);
Assert.NotEqual(GuidGenerator.Get(2), context.DerivedAsset.MyObject1.Id);
Assert.Equal(context.DerivedAsset.MyObject1, context.DerivedAsset.MyObject2);
}
public void TestSimpleCollectionAddMultipleAndCheckOrder()
{
var asset = new Types.MyAsset2 {
MyStrings = { "String1", "String2", "String3", "String4" }
};
var context = DeriveAssetTest <Types.MyAsset2, Types.MyAssetBasePropertyGraph> .DeriveAsset(asset);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyStrings);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyStrings);
var basePropertyNode = context.BaseGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
var derivedPropertyNode = context.DerivedGraph.RootNode[nameof(Types.MyAsset2.MyStrings)];
derivedPropertyNode.Target.Add("String3.5", new NodeIndex(3));
derivedPropertyNode.Target.Add("String1.5", new NodeIndex(1));
Assert.Equal(6, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Target.Add("String0.1", new NodeIndex(0));
Assert.Equal(5, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode, "String0.1", "String1", "String2", "String3", "String4");
Assert.Equal(7, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String0.1", "String1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Target.Add("String1.1", new NodeIndex(2));
Assert.Equal(6, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode, "String0.1", "String1", "String1.1", "String2", "String3", "String4");
Assert.Equal(8, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String0.1", "String1", "String1.1", "String1.5", "String2", "String3", "String3.5", "String4");
basePropertyNode.Target.Add("String2.1", new NodeIndex(4));
Assert.Equal(7, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String4");
Assert.Equal(9, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.5", "String4");
basePropertyNode.Target.Add("String3.1", new NodeIndex(6));
Assert.Equal(8, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String3.1", "String4");
Assert.Equal(10, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.1", "String3.5", "String4");
basePropertyNode.Target.Add("String4.1", new NodeIndex(8));
Assert.Equal(9, context.BaseAsset.MyStrings.Count);
AssertCollection(basePropertyNode, "String0.1", "String1", "String1.1", "String2", "String2.1", "String3", "String3.1", "String4", "String4.1");
Assert.Equal(11, context.DerivedAsset.MyStrings.Count);
AssertCollection(derivedPropertyNode, "String0.1", "String1", "String1.1", "String1.5", "String2", "String2.1", "String3", "String3.1", "String3.5", "String4", "String4.1");
Assert.Equal(9, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(11, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(baseIds[0], derivedIds[0]);
Assert.Equal(baseIds[1], derivedIds[1]);
Assert.Equal(baseIds[2], derivedIds[2]);
Assert.Equal(baseIds[3], derivedIds[4]);
Assert.Equal(baseIds[4], derivedIds[5]);
Assert.Equal(baseIds[5], derivedIds[6]);
Assert.Equal(baseIds[6], derivedIds[7]);
Assert.Equal(baseIds[7], derivedIds[9]);
Assert.Equal(baseIds[8], derivedIds[10]);
}
public void TestDictionaryRenameItemFromBase()
{
const string baseYaml = @"!Xenko.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Xenko.Core.Assets.Quantum.Tests
Id: 10000000-0000-0000-0000-000000000000
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
24000000240000002400000024000000~Key2Renamed: String2
14000000140000001400000014000000~Key3Renamed: String3
34000000340000003400000034000000~Key4Renamed: String4
";
const string derivedYaml = @"!Xenko.Core.Assets.Quantum.Tests.Helpers.Types+MyAsset3,Xenko.Core.Assets.Quantum.Tests
Id: 20000000-0000-0000-0000-000000000000
Archetype: 10000000-0000-0000-0000-000000000000:MyAsset
Tags: []
MyDictionary:
0a0000000a0000000a0000000a000000~Key1: String1
24000000240000002400000024000000~Key2: String2
14000000140000001400000014000000*~Key3: MyDerivedString
34000000340000003400000034000000~Key4*: MyDerivedString
";
var context = DeriveAssetTest <Types.MyAsset3, Types.MyAssetBasePropertyGraph> .LoadFromYaml(baseYaml, derivedYaml);
var baseIds = CollectionItemIdHelper.GetCollectionItemIds(context.BaseAsset.MyDictionary);
var derivedIds = CollectionItemIdHelper.GetCollectionItemIds(context.DerivedAsset.MyDictionary);
Assert.Equal(4, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.BaseAsset.MyDictionary["Key2Renamed"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3Renamed"]);
Assert.Equal("String4", context.BaseAsset.MyDictionary["Key4Renamed"]);
Assert.Equal(4, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key2"]);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyDictionary["Key3"]);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyDictionary["Key4"]);
Assert.Equal(4, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), baseIds["Key2Renamed"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key3Renamed"]);
Assert.Equal(IdentifierGenerator.Get(52), baseIds["Key4Renamed"]);
Assert.Equal(4, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds["Key2"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key3"]);
Assert.Equal(IdentifierGenerator.Get(52), derivedIds["Key4"]);
context.DerivedGraph.ReconcileWithBase();
Assert.Equal(4, context.BaseAsset.MyDictionary.Count);
Assert.Equal("String1", context.BaseAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.BaseAsset.MyDictionary["Key2Renamed"]);
Assert.Equal("String3", context.BaseAsset.MyDictionary["Key3Renamed"]);
Assert.Equal(4, context.DerivedAsset.MyDictionary.Count);
Assert.Equal("String1", context.DerivedAsset.MyDictionary["Key1"]);
Assert.Equal("String2", context.DerivedAsset.MyDictionary["Key2Renamed"]);
Assert.Equal("MyDerivedString", context.DerivedAsset.MyDictionary["Key3Renamed"]);
Assert.Equal("String4", context.DerivedAsset.MyDictionary["Key4"]);
Assert.Equal(4, baseIds.KeyCount);
Assert.Equal(0, baseIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), baseIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), baseIds["Key2Renamed"]);
Assert.Equal(IdentifierGenerator.Get(20), baseIds["Key3Renamed"]);
Assert.Equal(IdentifierGenerator.Get(52), baseIds["Key4Renamed"]);
Assert.Equal(4, derivedIds.KeyCount);
Assert.Equal(0, derivedIds.DeletedCount);
Assert.Equal(IdentifierGenerator.Get(10), derivedIds["Key1"]);
Assert.Equal(IdentifierGenerator.Get(36), derivedIds["Key2Renamed"]);
Assert.Equal(IdentifierGenerator.Get(20), derivedIds["Key3Renamed"]);
Assert.Equal(IdentifierGenerator.Get(52), derivedIds["Key4"]);
}