public void BasicDynamicTest()
        {
            var outer = new BasicDynamicTestOuter();
            var inner = new BasicDynamicTestInner();

            outer.Foo = inner;

            var model = TypeModel.Create();

            model.Add(typeof(BasicDynamicTestOuter), true);
            model.Add(typeof(BasicDynamicTestInner), true);   // assume we can at least know candidates at runtime, for now

            Assert.NotNull(outer.Foo);                        //, "not null before");
            Assert.IsType <BasicDynamicTestInner>(outer.Foo); //, "typed before");

            var clone = (BasicDynamicTestOuter)model.DeepClone(outer);

            Assert.NotNull(clone);                            //, "clone exists (runtime)");
            Assert.NotSame(outer, clone);                     //, "clone is different (runtime)");
            Assert.NotNull(clone.Foo);                        //, "not null after (runtime)");
            Assert.IsType <BasicDynamicTestInner>(outer.Foo); //, "typed after (runtime)");

            model.CompileInPlace();
            clone = (BasicDynamicTestOuter)model.DeepClone(outer);
            Assert.NotNull(clone);                            //, "clone exists (compile in place)");
            Assert.NotSame(outer, clone);                     //, "clone is different (compile in place)");
            Assert.NotNull(clone.Foo);                        //, "not null after (compile in place)");
            Assert.IsType <BasicDynamicTestInner>(outer.Foo); //, "typed after (compile in place)");

            clone = (BasicDynamicTestOuter)model.Compile().DeepClone(outer);
            Assert.NotNull(clone);                            //, "clone exists (full compile)");
            Assert.NotSame(outer, clone);                     //, "clone is different (full compile)");
            Assert.NotNull(clone.Foo);                        //, "not null after (full compile)");
            Assert.IsType <BasicDynamicTestInner>(outer.Foo); //, "typed after (full compile)");
        }
Пример #2
0
        public void BasicDynamicTest()
        {
            var outer = new BasicDynamicTestOuter();
            var inner = new BasicDynamicTestInner();
            outer.Foo = inner;

            var model = TypeModel.Create();
            model.Add(typeof(BasicDynamicTestOuter), true);
            model.Add(typeof(BasicDynamicTestInner), true); // assume we can at least know candidates at runtime, for now

            Assert.IsNotNull(outer.Foo, "not null before");
            Assert.IsInstanceOfType(typeof(BasicDynamicTestInner), outer.Foo, "typed before");

            var clone = (BasicDynamicTestOuter)model.DeepClone(outer);
            Assert.IsNotNull(clone, "clone exists (runtime)");
            Assert.AreNotSame(outer, clone, "clone is different (runtime)");
            Assert.IsNotNull(clone.Foo, "not null after (runtime)");
            Assert.IsInstanceOfType(typeof(BasicDynamicTestInner), outer.Foo, "typed after (runtime)");

            model.CompileInPlace();
            clone = (BasicDynamicTestOuter)model.DeepClone(outer);
            Assert.IsNotNull(clone, "clone exists (compile in place)");
            Assert.AreNotSame(outer, clone, "clone is different (compile in place)");
            Assert.IsNotNull(clone.Foo, "not null after (compile in place)");
            Assert.IsInstanceOfType(typeof(BasicDynamicTestInner), outer.Foo, "typed after (compile in place)");

            clone = (BasicDynamicTestOuter)model.Compile().DeepClone(outer);
            Assert.IsNotNull(clone, "clone exists (full compile)");
            Assert.AreNotSame(outer, clone, "clone is different (full compile)");
            Assert.IsNotNull(clone.Foo, "not null after (full compile)");
            Assert.IsInstanceOfType(typeof(BasicDynamicTestInner), outer.Foo, "typed after (full compile)");
        }