C# (CSharp) ClassWithListsの例

コード例 #1

        public void TestConstruction()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            Assert.That(model["IntList"].Retrieve(), Is.SameAs(obj.IntList));
            Assert.That(model["IntList"].IsReference, Is.False);
            Assert.That(model["ClassList"].Retrieve(), Is.SameAs(obj.ClassList));
            //Assert.That(model["ClassList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model["SimpleStructList"].Retrieve(), Is.SameAs(obj.SimpleStructList));
            //Assert.That(model["SimpleStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model["NestedStructList"].Retrieve(), Is.SameAs(obj.NestedStructList));
            //Assert.That(model["NestedStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model["ListOfSimpleStructLists"].Retrieve(), Is.SameAs(obj.ListOfSimpleStructLists));
            //Assert.That(model["ListOfSimpleStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model["ListOfSimpleStructLists"].Target.ItemReferences)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }
            Assert.That(model["ListOfNestedStructLists"].Retrieve(), Is.SameAs(obj.ListOfNestedStructLists));
            //Assert.That(model["ListOfNestedStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model["ListOfNestedStructLists"].Target.ItemReferences)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }

            Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null);
        }

コード例 #2

        public void TestStructItemUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            //var objRef = ((ReferenceEnumerable)model["SimpleStructList"].Reference).First();
            //objRef.TargetNode["SecondValue"].Update(32);
            Assert.Equal(32, obj.SimpleStructList[0].SecondValue);
        }

コード例 #3

ファイル: ObsoleteTestLists.cs プロジェクト: Kryptos-FR/xenko-archive

        public void TestObjectItemUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            //var objRef = ((ReferenceEnumerable)model["ClassList"].Reference).First();
            //objRef.TargetNode["SecondValue"].Update(32);
            Assert.That(obj.ClassList[0].SecondValue, Is.EqualTo(32));
        }

コード例 #4

        public void TestListOfSimpleStructListsUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            //var listRef = ((ReferenceEnumerable)model["ListOfSimpleStructLists"].Reference).Last();
            //var objRef = ((ReferenceEnumerable)listRef.TargetNode.Reference).Last();
            //objRef.TargetNode["SecondValue"].Update(32);
            Assert.Equal(32, obj.ListOfSimpleStructLists[1][0].SecondValue);
        }

コード例 #5

        public void TestPrimitiveItemUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            ((List <int>)model["IntList"].Retrieve())[1] = 42;
            ((List <int>)model["IntList"].Retrieve()).Add(26);
            Assert.Equal(4, obj.IntList.Count);
            Assert.Equal(42, obj.IntList[1]);
            Assert.Equal(26, obj.IntList[3]);
        }

コード例 #6

ファイル: TestLists.cs プロジェクト: Hengle/xenko

        public void TestConstruction()
        {
            var        obj       = new ClassWithLists();
            var        container = new ModelContainer();
            IModelNode model     = container.GetOrCreateModelNode(obj, obj.GetType());

            Console.WriteLine(model.PrintHierarchy());
            foreach (var guid in container.Guids)
            {
                var node = container.GetModelNode(guid);
                if (model != node)
                {
                    Console.WriteLine(node.PrintHierarchy());
                }
            }

            Assert.That(model.GetChild("IntList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("IntList").Content.Value, Is.SameAs(obj.IntList));
            Assert.That(model.GetChild("IntList").Content.IsReference, Is.False);
            Assert.That(model.GetChild("ClassList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ClassList").Content.Value, Is.SameAs(obj.ClassList));
            Assert.That(model.GetChild("ClassList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("SimpleStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("SimpleStructList").Content.Value, Is.SameAs(obj.SimpleStructList));
            Assert.That(model.GetChild("SimpleStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("NestedStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("NestedStructList").Content.Value, Is.SameAs(obj.NestedStructList));
            Assert.That(model.GetChild("NestedStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Value, Is.SameAs(obj.ListOfSimpleStructLists));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfSimpleStructLists").Content.Reference)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }
            Assert.That(model.GetChild("ListOfNestedStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Value, Is.SameAs(obj.ListOfNestedStructLists));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }

            Assert.That(container.GetModelNode(obj.ClassList[0]), !Is.Null);
            Assert.That(container.Guids.Count(), Is.EqualTo(14));
            var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);

            visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
            foreach (var node in container.Models)
            {
                visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
            }
        }

コード例 #7

ファイル: ObsoleteTestLists.cs プロジェクト: Kryptos-FR/xenko-archive

        public void TestListOfNestedStructListsUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            //var listRef = ((ReferenceEnumerable)model["ListOfNestedStructLists"].Reference).Last();
            //var objRef = ((ReferenceEnumerable)listRef.TargetNode.Reference).Last();
            //var structNode = container.GetNode(((ObjectReference)objRef.TargetNode["Struct"].Reference).TargetGuid);
            //structNode["SecondValue"].Update(32);
            Assert.That(obj.ListOfNestedStructLists[1][0].Struct.SecondValue, Is.EqualTo(32));
        }

コード例 #8

ファイル: ObsoleteTestLists.cs プロジェクト: Kryptos-FR/xenko-archive

        public void TestPrimitiveItemUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            Console.WriteLine(model.PrintHierarchy());
            ((List <int>)model["IntList"].Value)[1] = 42;
            ((List <int>)model["IntList"].Value).Add(26);
            Assert.That(obj.IntList.Count, Is.EqualTo(4));
            Assert.That(obj.IntList[1], Is.EqualTo(42));
            Assert.That(obj.IntList[3], Is.EqualTo(26));
        }

コード例 #9

        public void TestNestedStructItemUpdate()
        {
            var obj       = new ClassWithLists();
            var container = new NodeContainer();
            var model     = container.GetOrCreateNode(obj);

            //var objRef = ((ReferenceEnumerable)model["NestedStructList"].Reference).First();
            //var structNode = container.GetNode(((ObjectReference)objRef.TargetNode["Struct"].Reference).TargetGuid);
            //structNode["SecondValue"].Update(32);
            Assert.Equal(32, obj.NestedStructList[0].Struct.SecondValue);
            //var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
            //visitor.Check((GraphNode)model, obj, typeof(ClassWithLists), true);
        }

コード例 #10

ファイル: ObsoleteTestLists.cs プロジェクト: rohitshe/Code

        public void TestPrimitiveItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new NodeContainer();
            IGraphNode model     = container.GetOrCreateNode(obj);

            Console.WriteLine(model.PrintHierarchy());
            ((List <int>)model.GetChild("IntList").Content.Value)[1] = 42;
            ((List <int>)model.GetChild("IntList").Content.Value).Add(26);
            Assert.That(obj.IntList.Count, Is.EqualTo(4));
            Assert.That(obj.IntList[1], Is.EqualTo(42));
            Assert.That(obj.IntList[3], Is.EqualTo(26));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #11

ファイル: ObsoleteTestLists.cs プロジェクト: rohitshe/Code

        public void TestStructItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new NodeContainer();
            IGraphNode model     = container.GetOrCreateNode(obj);

            Helper.PrintModelContainerContent(container, model);
            var objRef = ((ReferenceEnumerable)model.GetChild("SimpleStructList").Content.Reference).First();

            objRef.TargetNode.GetChild("SecondValue").Content.Update(32);
            Helper.PrintModelContainerContent(container, model);
            Assert.That(obj.SimpleStructList[0].SecondValue, Is.EqualTo(32));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #12

        public void TestObjectItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new ModelContainer();
            IModelNode model     = container.GetOrCreateModelNode(obj, obj.GetType());

            Helper.PrintModelContainerContent(container, model);
            var objRef = ((ReferenceEnumerable)model.GetChild("ClassList").Content.Reference).First();

            objRef.TargetNode.GetChild("SecondValue").Content.Value = 32;
            Helper.PrintModelContainerContent(container, model);
            Assert.That(obj.ClassList[0].SecondValue, Is.EqualTo(32));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #13

        public void TestListOfSimpleStructListsUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new ModelContainer();
            IModelNode model     = container.GetOrCreateModelNode(obj, obj.GetType());

            Helper.PrintModelContainerContent(container, model);
            var listRef = ((ReferenceEnumerable)model.GetChild("ListOfSimpleStructLists").Content.Reference).Last();
            var objRef  = ((ReferenceEnumerable)listRef.TargetNode.Content.Reference).Last();

            objRef.TargetNode.GetChild("SecondValue").Content.Value = 32;
            Helper.PrintModelContainerContent(container, model);
            Assert.That(obj.ListOfSimpleStructLists[1][0].SecondValue, Is.EqualTo(32));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #14

ファイル: ObsoleteTestLists.cs プロジェクト: rohitshe/Code

        public void TestListOfNestedStructListsUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new NodeContainer();
            IGraphNode model     = container.GetOrCreateNode(obj);

            Helper.PrintModelContainerContent(container, model);
            var listRef    = ((ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference).Last();
            var objRef     = ((ReferenceEnumerable)listRef.TargetNode.Content.Reference).Last();
            var structNode = container.GetNode(((ObjectReference)objRef.TargetNode.GetChild("Struct").Content.Reference).TargetGuid);

            structNode.GetChild("SecondValue").Content.Update(32);
            Helper.PrintModelContainerContent(container, model);
            Assert.That(obj.ListOfNestedStructLists[1][0].Struct.SecondValue, Is.EqualTo(32));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #15

        public void TestNestedStructItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new NodeContainer();
            IGraphNode model     = container.GetOrCreateNode(obj);

            Helper.PrintModelContainerContent(container, model);
            var objRef     = ((ReferenceEnumerable)model.GetChild("NestedStructList").Content.Reference).First();
            var structNode = container.GetNode(((ObjectReference)objRef.TargetNode.GetChild("Struct").Content.Reference).TargetGuid);

            structNode.GetChild("SecondValue").Content.Update(32);
            Helper.PrintModelContainerContent(container, model);
            Assert.That(obj.NestedStructList[0].Struct.SecondValue, Is.EqualTo(32));
            //var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
            //visitor.Check((GraphNode)model, obj, typeof(ClassWithLists), true);
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #16

ファイル: TestLists.cs プロジェクト: Hengle/xenko

        public void TestNestedStructItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new ModelContainer();
            IModelNode model     = container.GetOrCreateModelNode(obj, obj.GetType());

            Console.WriteLine(model.PrintHierarchy());
            var objRef = ((ReferenceEnumerable)model.GetChild("NestedStructList").Content.Reference).First();

            objRef.TargetNode.GetChild("Struct").GetChild("SecondValue").Content.Value = 32;
            Assert.That(obj.NestedStructList[0].Struct.SecondValue, Is.EqualTo(32));
            var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);

            visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
            foreach (var node in container.Models)
            {
                visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
            }
        }

コード例 #17

ファイル: TestLists.cs プロジェクト: Hengle/xenko

        public void TestPrimitiveItemUpdate()
        {
            var        obj       = new ClassWithLists();
            var        container = new ModelContainer();
            IModelNode model     = container.GetOrCreateModelNode(obj, obj.GetType());

            Console.WriteLine(model.PrintHierarchy());
            ((List <int>)model.GetChild("IntList").Content.Value)[1] = 42;
            ((List <int>)model.GetChild("IntList").Content.Value).Add(26);
            Assert.That(obj.IntList.Count, Is.EqualTo(4));
            Assert.That(obj.IntList[1], Is.EqualTo(42));
            Assert.That(obj.IntList[3], Is.EqualTo(26));
            var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);

            visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
            foreach (var node in container.Models)
            {
                visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
            }
        }

コード例 #18

ファイル: ObsoleteTestLists.cs プロジェクト: rohitshe/Code

        public void TestConstruction()
        {
            var        obj       = new ClassWithLists();
            var        container = new NodeContainer();
            IGraphNode model     = container.GetOrCreateNode(obj);

            Helper.PrintModelContainerContent(container, model);

            Assert.That(model.GetChild("IntList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("IntList").Content.Value, Is.SameAs(obj.IntList));
            Assert.That(model.GetChild("IntList").Content.IsReference, Is.False);
            Assert.That(model.GetChild("ClassList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ClassList").Content.Value, Is.SameAs(obj.ClassList));
            Assert.That(model.GetChild("ClassList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("SimpleStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("SimpleStructList").Content.Value, Is.SameAs(obj.SimpleStructList));
            Assert.That(model.GetChild("SimpleStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("NestedStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("NestedStructList").Content.Value, Is.SameAs(obj.NestedStructList));
            Assert.That(model.GetChild("NestedStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Value, Is.SameAs(obj.ListOfSimpleStructLists));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model.GetChild("ListOfSimpleStructLists").Content.Reference.AsEnumerable)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }
            Assert.That(model.GetChild("ListOfNestedStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Value, Is.SameAs(obj.ListOfNestedStructLists));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model.GetChild("ListOfNestedStructLists").Content.Reference.AsEnumerable)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }

            Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null);
            Assert.That(container.Guids.Count(), Is.EqualTo(18));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #19

ファイル: ObsoleteTestLists.cs プロジェクト: cg123/xenko

        public void TestConstruction()
        {
            var obj = new ClassWithLists();
            var container = new NodeContainer();
            IGraphNode model = container.GetOrCreateNode(obj);
            Helper.PrintModelContainerContent(container, model);

            Assert.That(model.GetChild("IntList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("IntList").Content.Value, Is.SameAs(obj.IntList));
            Assert.That(model.GetChild("IntList").Content.IsReference, Is.False);
            Assert.That(model.GetChild("ClassList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ClassList").Content.Value, Is.SameAs(obj.ClassList));
            Assert.That(model.GetChild("ClassList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("SimpleStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("SimpleStructList").Content.Value, Is.SameAs(obj.SimpleStructList));
            Assert.That(model.GetChild("SimpleStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("NestedStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("NestedStructList").Content.Value, Is.SameAs(obj.NestedStructList));
            Assert.That(model.GetChild("NestedStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Value, Is.SameAs(obj.ListOfSimpleStructLists));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model.GetChild("ListOfSimpleStructLists").Content.Reference.AsEnumerable)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }
            Assert.That(model.GetChild("ListOfNestedStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Value, Is.SameAs(obj.ListOfNestedStructLists));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in model.GetChild("ListOfNestedStructLists").Content.Reference.AsEnumerable)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }

            Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null);
            Assert.That(container.Guids.Count(), Is.EqualTo(18));
            Helper.ConsistencyCheck(container, obj);
        }

コード例 #20

ファイル: ObsoleteTestLists.cs プロジェクト: cg123/xenko

 public void TestListOfNestedStructListsUpdate()
 {
     var obj = new ClassWithLists();
     var container = new NodeContainer();
     IGraphNode model = container.GetOrCreateNode(obj);
     Helper.PrintModelContainerContent(container, model);
     var listRef = ((ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference).Last();
     var objRef = ((ReferenceEnumerable)listRef.TargetNode.Content.Reference).Last();
     var structNode = container.GetNode(((ObjectReference)objRef.TargetNode.GetChild("Struct").Content.Reference).TargetGuid);
     structNode.GetChild("SecondValue").Content.Update(32);
     Helper.PrintModelContainerContent(container, model);
     Assert.That(obj.ListOfNestedStructLists[1][0].Struct.SecondValue, Is.EqualTo(32));
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #21

ファイル: ObsoleteTestLists.cs プロジェクト: cg123/xenko

 public void TestNestedStructItemUpdate()
 {
     var obj = new ClassWithLists();
     var container = new NodeContainer();
     IGraphNode model = container.GetOrCreateNode(obj);
     Helper.PrintModelContainerContent(container, model);
     var objRef = ((ReferenceEnumerable)model.GetChild("NestedStructList").Content.Reference).First();
     var structNode = container.GetNode(((ObjectReference)objRef.TargetNode.GetChild("Struct").Content.Reference).TargetGuid);
     structNode.GetChild("SecondValue").Content.Update(32);
     Helper.PrintModelContainerContent(container, model);
     Assert.That(obj.NestedStructList[0].Struct.SecondValue, Is.EqualTo(32));
     //var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
     //visitor.Check((GraphNode)model, obj, typeof(ClassWithLists), true);
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #22

ファイル: ObsoleteTestLists.cs プロジェクト: cg123/xenko

 public void TestStructItemUpdate()
 {
     var obj = new ClassWithLists();
     var container = new NodeContainer();
     IGraphNode model = container.GetOrCreateNode(obj);
     Helper.PrintModelContainerContent(container, model);
     var objRef = ((ReferenceEnumerable)model.GetChild("SimpleStructList").Content.Reference).First();
     objRef.TargetNode.GetChild("SecondValue").Content.Update(32);
     Helper.PrintModelContainerContent(container, model);
     Assert.That(obj.SimpleStructList[0].SecondValue, Is.EqualTo(32));
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #23

ファイル: ObsoleteTestLists.cs プロジェクト: cg123/xenko

 public void TestPrimitiveItemUpdate()
 {
     var obj = new ClassWithLists();
     var container = new NodeContainer();
     IGraphNode model = container.GetOrCreateNode(obj);
     Console.WriteLine(model.PrintHierarchy());
     ((List<int>)model.GetChild("IntList").Content.Value)[1] = 42;
     ((List<int>)model.GetChild("IntList").Content.Value).Add(26);
     Assert.That(obj.IntList.Count, Is.EqualTo(4));
     Assert.That(obj.IntList[1], Is.EqualTo(42));
     Assert.That(obj.IntList[3], Is.EqualTo(26));
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #24

ファイル: TestLists.cs プロジェクト: Powerino73/paradox

        public void TestConstruction()
        {
            var obj = new ClassWithLists();
            var container = new ModelContainer();
            IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
            Console.WriteLine(model.PrintHierarchy());
            foreach (var guid in container.Guids)
            {
                var node = container.GetModelNode(guid);
                if (model != node)
                    Console.WriteLine(node.PrintHierarchy());
            }

            Assert.That(model.GetChild("IntList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("IntList").Content.Value, Is.SameAs(obj.IntList));
            Assert.That(model.GetChild("IntList").Content.IsReference, Is.False);
            Assert.That(model.GetChild("ClassList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ClassList").Content.Value, Is.SameAs(obj.ClassList));
            Assert.That(model.GetChild("ClassList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("SimpleStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("SimpleStructList").Content.Value, Is.SameAs(obj.SimpleStructList));
            Assert.That(model.GetChild("SimpleStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("NestedStructList").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("NestedStructList").Content.Value, Is.SameAs(obj.NestedStructList));
            Assert.That(model.GetChild("NestedStructList").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Value, Is.SameAs(obj.ListOfSimpleStructLists));
            Assert.That(model.GetChild("ListOfSimpleStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfSimpleStructLists").Content.Reference)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }
            Assert.That(model.GetChild("ListOfNestedStructLists").Children.Count, Is.EqualTo(0));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Value, Is.SameAs(obj.ListOfNestedStructLists));
            Assert.That(model.GetChild("ListOfNestedStructLists").Content.Reference, Is.AssignableFrom(typeof(ReferenceEnumerable)));
            foreach (var reference in (ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference)
            {
                Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference)));
            }

            Assert.That(container.GetModelNode(obj.ClassList[0]), !Is.Null);
            Assert.That(container.Guids.Count(), Is.EqualTo(14));
            var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
            visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
            foreach (var node in container.Models)
            {
                visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
            }
        }

コード例 #25

ファイル: TestLists.cs プロジェクト: h78hy78yhoi8j/xenko

 public void TestObjectItemUpdate()
 {
     var obj = new ClassWithLists();
     var container = new ModelContainer();
     IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
     Helper.PrintModelContainerContent(container, model);
     var objRef = ((ReferenceEnumerable)model.GetChild("ClassList").Content.Reference).First();
     objRef.TargetNode.GetChild("SecondValue").Content.Value = 32;
     Helper.PrintModelContainerContent(container, model);
     Assert.That(obj.ClassList[0].SecondValue, Is.EqualTo(32));
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #26

ファイル: TestLists.cs プロジェクト: h78hy78yhoi8j/xenko

 public void TestListOfSimpleStructListsUpdate()
 {
     var obj = new ClassWithLists();
     var container = new ModelContainer();
     IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
     Helper.PrintModelContainerContent(container, model);
     var listRef = ((ReferenceEnumerable)model.GetChild("ListOfSimpleStructLists").Content.Reference).Last();
     var objRef = ((ReferenceEnumerable)listRef.TargetNode.Content.Reference).Last();
     objRef.TargetNode.GetChild("SecondValue").Content.Value = 32;
     Helper.PrintModelContainerContent(container, model);
     Assert.That(obj.ListOfSimpleStructLists[1][0].SecondValue, Is.EqualTo(32));
     Helper.ConsistencyCheck(container, obj);
 }

コード例 #27

ファイル: TestLists.cs プロジェクト: Powerino73/paradox

 public void TestListOfNestedStructListsUpdate()
 {
     var obj = new ClassWithLists();
     var container = new ModelContainer();
     IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
     Console.WriteLine(model.PrintHierarchy());
     var listRef = ((ReferenceEnumerable)model.GetChild("ListOfNestedStructLists").Content.Reference).Last();
     var objRef = ((ReferenceEnumerable)listRef.TargetNode.Content.Reference).Last();
     objRef.TargetNode.GetChild("Struct").GetChild("SecondValue").Content.Value = 32;
     Assert.That(obj.ListOfNestedStructLists[1][0].Struct.SecondValue, Is.EqualTo(32));
     var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
     visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
     foreach (var node in container.Models)
     {
         visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
     }
 }

コード例 #28

ファイル: TestLists.cs プロジェクト: Powerino73/paradox

 public void TestPrimitiveItemUpdate()
 {
     var obj = new ClassWithLists();
     var container = new ModelContainer();
     IModelNode model = container.GetOrCreateModelNode(obj, obj.GetType());
     Console.WriteLine(model.PrintHierarchy());
     ((List<int>)model.GetChild("IntList").Content.Value)[1] = 42;
     ((List<int>)model.GetChild("IntList").Content.Value).Add(26);
     Assert.That(obj.IntList.Count, Is.EqualTo(4));
     Assert.That(obj.IntList[1], Is.EqualTo(42));
     Assert.That(obj.IntList[3], Is.EqualTo(26));
     var visitor = new ModelConsistencyCheckVisitor(container.NodeBuilder);
     visitor.Check((ModelNode)model, obj, typeof(ClassWithLists), true);
     foreach (var node in container.Models)
     {
         visitor.Check((ModelNode)node, node.Content.Value, node.Content.Type, true);
     }
 }