public void TestNestedSerialization()
        {
            //var asset = AssetFileSerializer.Load<Types.MyAssetHierarchy>(AssetTestContainer.ToStream(text), $"MyAsset{Types.FileExtension}");
            var asset = new Types.MyAssetHierarchy();

            asset.Hierarchy.Parts.Add(new Types.MyPartDesign {
                Part = new Types.MyPart {
                    Id = GuidGenerator.Get(1)
                }
            });
            asset.Hierarchy.Parts.Add(new Types.MyPartDesign {
                Part = new Types.MyPart {
                    Id = GuidGenerator.Get(2)
                }
            });
            asset.Hierarchy.Parts.Add(new Types.MyPartDesign {
                Part = new Types.MyPart {
                    Id = GuidGenerator.Get(3), Children = { asset.Hierarchy.Parts[GuidGenerator.Get(2)].Part }
                }
            });
            asset.Hierarchy.Parts.Add(new Types.MyPartDesign {
                Part = new Types.MyPart {
                    Id = GuidGenerator.Get(4), Children = { asset.Hierarchy.Parts[GuidGenerator.Get(1)].Part }
                }
            });
            asset.Hierarchy.RootParts.Add(asset.Hierarchy.Parts[GuidGenerator.Get(2)].Part);
            asset.Hierarchy.RootParts.Add(asset.Hierarchy.Parts[GuidGenerator.Get(1)].Part);
            var context = new AssetTestContainer <Types.MyAssetHierarchy, Types.MyAssetHierarchyPropertyGraph>(asset);

            context.BuildGraph();
            SerializationHelper.SerializeAndCompare(context.AssetItem, context.Graph, NestedHierarchyYaml, false);
        }
Exemple #2
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 TestSimpleDeserialization()
        {
            var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(SimpleHierarchyYaml), $"MyAsset{Types.FileExtension}");

            Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count);
            Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id);
            Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id);
            Assert.Equal(2, asset.Asset.Hierarchy.Parts.Count);
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1)));
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2)));
        }
        public void TestMissortedPartsDeserialization()
        {
            var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(MissortedHierarchyYaml), $"MyAsset{Types.FileExtension}");

            Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count);
            Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id);
            Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id);
            Assert.Equal(4, asset.Asset.Hierarchy.Parts.Count);
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1)));
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2)));
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(3)));
            Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(4)));
            Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children);
            Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(2)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children[0]);
            Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children);
            Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(1)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children[0]);
        }
Exemple #5
0
        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 TestSimpleReference()
        {
            Types.AssetWithRefPropertyGraphDefinition.IsObjectReferenceFunc = (targetNode, index) =>
            {
                return((targetNode as IMemberNode)?.Name == nameof(Types.MyAssetWithRef.MyObject2));
            };
            var obj = new Types.MyReferenceable {
                Id = GuidGenerator.Get(2), Value = "MyInstance"
            };
            var asset = new Types.MyAssetWithRef {
                MyObject1 = obj, MyObject2 = obj
            };
            var context = new AssetTestContainer <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph>(asset);

            context.BuildGraph();
            SerializationHelper.SerializeAndCompare(context.AssetItem, context.Graph, SimpleReferenceYaml, false);

            context = AssetTestContainer <Types.MyAssetWithRef, Types.MyAssetBasePropertyGraph> .LoadFromYaml(SimpleReferenceYaml);

            Assert.Equal(context.Asset.MyObject1, context.Asset.MyObject2);
            Assert.Equal(GuidGenerator.Get(2), context.Asset.MyObject1.Id);
        }
Exemple #7
0
 private DeriveAssetTest(AssetTestContainer <TAsset, TAssetPropertyGraph> baseAsset, AssetTestContainer <TAsset, TAssetPropertyGraph> derivedAsset, AssetTestContainer <TAsset, TAssetPropertyGraph> subDerivedAsset)
 {
     Base       = baseAsset;
     Derived    = derivedAsset;
     SubDerived = subDerivedAsset;
 }