C# (CSharp) ofRootNode.RenderElement Examples

Example #1

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(OneRendered, Is.True);
                Assert.That(TwoRendered, Is.False);

                OneRendered = false;
                DoAlt       = true;

                node.RenderElement(this);

                Assert.That(OneRendered, Is.False);
                Assert.That(TwoRendered, Is.True);

                TwoRendered = false;
                DoAlt       = false;

                node.RenderElement(this);

                Assert.That(OneRendered, Is.True);
                Assert.That(TwoRendered, Is.False);
            }

Example #2

            public void Test()
            {
                using var node = new ofRootNode();

                State = 0;

                node.RenderElement(this);

                Assert.That(Rendered, Is.EqualTo(0));

                State = 1;

                node.RenderElement(this);

                Assert.That(Rendered, Is.EqualTo(1));

                State = 0;

                node.RenderElement(this);

                Assert.That(Rendered, Is.EqualTo(1));

                State = 2;

                node.RenderElement(this);

                Assert.That(Rendered, Is.EqualTo(2));
            }

Example #3

File: UseEffectTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                var node = new ofRootNode();

                Assert.That(Effect, Is.EqualTo(0));
                Assert.That(Cleanup, Is.EqualTo(0));

                node.RenderElement(this);

                Assert.That(Effect, Is.EqualTo(1));
                Assert.That(Cleanup, Is.EqualTo(0));

                node.RenderElement(this);

                Assert.That(Effect, Is.EqualTo(2));
                Assert.That(Cleanup, Is.EqualTo(1));

                node.RenderElement(this);

                Assert.That(Effect, Is.EqualTo(3));
                Assert.That(Cleanup, Is.EqualTo(2));

                node.Dispose();

                Assert.That(Effect, Is.EqualTo(3));
                Assert.That(Cleanup, Is.EqualTo(3));
            }

Example #4

File: ConstructorMatchingTests.cs Project: phosphene47/ofreact

        public void PartlyAmbiguousCtor()
        {
            var node = new ofRootNode();

            var context = new PartlyAmbiguousCtorElement.Context();

            // "my value" is unambiguously a string
            node.RenderElement(new ofContext <PartlyAmbiguousCtorElement.Context>(value: context)
            {
                new ofYamlComponent(key: 1, document: @"
render:
  PartlyAmbiguousCtorElement:
    value: my value")
            });

            Assert.That(context.TheType, Is.EqualTo(PartlyAmbiguousCtorElement.Type.String));

            // "765" can be parsed as string OR integer, so it is ambiguous
            Assert.That(() => node.RenderElement(new ofContext <PartlyAmbiguousCtorElement.Context>(value: context)
            {
                new ofYamlComponent(key: 2, document: @"
render:
  PartlyAmbiguousCtorElement:
    value: 765")
            }), Throws.InstanceOf <YamlComponentException>());
        }

Example #5

        public void MismatchingBind()
        {
            var node = new ofRootNode();

            node.RenderElement(new ElementTypeA());

            Assert.That(node.RenderElement(new ElementTypeB()), Is.EqualTo(RenderResult.Mismatch));
        }

Example #6

        public void Complex()
        {
            var node = new ofRootNode();

            Assert.That(MountCounting.Mount, Is.EqualTo(0));
            Assert.That(MountCounting.Unmount, Is.EqualTo(0));

            node.RenderElement(new[]
            {
                new MountCounting("first"),
                new MountCounting("second"),
                new MountCounting("third")
            });

            Assert.That(MountCounting.Mount, Is.EqualTo(3));
            Assert.That(MountCounting.Unmount, Is.EqualTo(0));

            node.RenderElement(new[]
            {
                new MountCounting("first"),
                new MountCounting("third")
            });

            Assert.That(MountCounting.Mount, Is.EqualTo(3));
            Assert.That(MountCounting.Unmount, Is.EqualTo(1));

            node.RenderElement(new[]
            {
                new MountCounting("third"),
                new MountCounting("first")
            });

            Assert.That(MountCounting.Mount, Is.EqualTo(3));
            Assert.That(MountCounting.Unmount, Is.EqualTo(1));

            node.RenderElement(new[]
            {
                new MountCounting("third"),
                new MountCounting("second"),
                new MountCounting("first")
            });

            Assert.That(MountCounting.Mount, Is.EqualTo(4));
            Assert.That(MountCounting.Unmount, Is.EqualTo(1));

            node.RenderElement(new[]
            {
                new MountCounting("first")
            });

            Assert.That(MountCounting.Mount, Is.EqualTo(4));
            Assert.That(MountCounting.Unmount, Is.EqualTo(3));

            node.Dispose();

            Assert.That(MountCounting.Mount, Is.EqualTo(4));
            Assert.That(MountCounting.Unmount, Is.EqualTo(4));
        }

Example #7

            public void Test()
            {
                var node = new ofRootNode();

                node.RenderElement(this);

                Alt = true;

                Assert.That(() => node.RenderElement(this), Throws.InstanceOf <InvalidCastException>());
            }

Example #8

File: LiftingStateUpTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(Renders, Is.EqualTo(11));

                node.RenderElement(this);

                Assert.That(Renders, Is.EqualTo(12));
            }

Example #9

File: RenderingTests.cs Project: phosphene47/ofreact

        public void SkipIfSameProps()
        {
            var node = new ofRootNode {
                AlwaysInvalid = false
            };                                                   // we don't want optimization

            Assert.That(SkipIfSamePropsElement.Rendered, Is.EqualTo(0));

            node.RenderElement(new SkipIfSamePropsElement("test"));

            Assert.That(SkipIfSamePropsElement.Rendered, Is.EqualTo(1));

            node.RenderElement(new SkipIfSamePropsElement("test"));

            Assert.That(SkipIfSamePropsElement.Rendered, Is.EqualTo(1));
        }

Example #10

File: ParserTests.cs Project: phosphene47/ofreact

        public void BadLowercaseName()
        {
            var node = new ofRootNode();

            Assert.That(() => node.RenderElement(new ofYamlComponent(@"
render:
  fragment:")), Throws.InstanceOf <YamlComponentException>()); // fragment should be titlecased
        }

Example #11

File: ParserTests.cs Project: phosphene47/ofreact

        public void NoRender()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(""));

            node.Diagnostics.EnsureRendered(typeof(ofYamlComponent));
        }

Example #12

            public void Test()
            {
                Assert.That(CurrentCount, Is.EqualTo(0));
                Assert.That(CurrentString, Is.Null);

                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(CurrentCount, Is.EqualTo(1));
                Assert.That(CurrentString, Is.EqualTo("1"));

                node.RenderElement(this);

                Assert.That(CurrentCount, Is.EqualTo(2));
                Assert.That(CurrentString, Is.EqualTo("2"));
            }

Example #13

File: ParserTests.cs Project: phosphene47/ofreact

        public void EmptyRenderMapping()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent("render: {}"));

            node.Diagnostics.EnsureRendered(typeof(ofYamlComponent));
        }

Example #14

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(Rendered, Is.True);
            }

Example #15

File: UseContextTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                using var node = new ofRootNode();

                Assert.That(Nested1Rendered, Is.EqualTo(0));
                Assert.That(Nested2Rendered, Is.EqualTo(0));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(1));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(1));
            }

Example #16

File: ConstructorMatchingTests.cs Project: phosphene47/ofreact

        public void PrivateCtor()
        {
            var node = new ofRootNode();

            Assert.That(() => node.RenderElement(new ofYamlComponent(@"
render:
  PrivateCtorElement:")), Throws.InstanceOf <YamlComponentException>());
        }

Example #17

File: ParserTests.cs Project: phosphene47/ofreact

        public void AbstractElement()
        {
            var node = new ofRootNode();

            Assert.That(() => node.RenderElement(new ofYamlComponent(@"
render:
  Element:")), Throws.InstanceOf <YamlComponentException>()); // ofElement is abstract
        }

Example #18

File: ConstructorMatchingTests.cs Project: phosphene47/ofreact

        public void MultiCtor()
        {
            var node = new ofRootNode();

            var context = new MultiCtorElement.Context();

            node.RenderElement(new ofContext <MultiCtorElement.Context>(value: context)
            {
                new ofYamlComponent(key: 1, document: @"
render:
  MultiCtorElement:
    value1: 1")
            });

            // exact match - 1 param
            Assert.That(context.Params, Is.EqualTo(1));

            node.RenderElement(new ofContext <MultiCtorElement.Context>(value: context)
            {
                new ofYamlComponent(key: 2, document: @"
render:
  MultiCtorElement:
    value1: 1
    value2: 2")
            });

            // closest match - 2 param with 1 optional (due to param 2 excess)
            Assert.That(context.Params, Is.EqualTo(3));

            node.RenderElement(new ofContext <MultiCtorElement.Context>(value: context)
            {
                new ofYamlComponent(key: 3, document: @"
render:
  MultiCtorElement:
    value1: 1
    value2: 2
    value3: 3
    value4: 4")
            });

            // closest match - 4 param with 1 optional (due to param 4 excess)
            Assert.That(context.Params, Is.EqualTo(5));
        }

Example #19

File: ParserTests.cs Project: phosphene47/ofreact

        public void EmptyRenderListValues()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(@"
render:
  -"));

            node.Diagnostics.EnsureRendered(typeof(ofYamlComponent));
        }

Example #20

File: UseStateTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(ParentRenders, Is.EqualTo(1));
                Assert.That(NestedRenders1, Is.EqualTo(11));
                Assert.That(NestedRenders2, Is.EqualTo(1));
            }

Example #21

        public void IgnoreNullChild()
        {
            using var node = new ofRootNode();

            node.RenderElement(new[]
            {
                new ofFragment(),
                null,
                new ofFragment()
            });
        }

Example #22

File: RenderDiagnosticsTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(() => node.Diagnostics.EnsureRendered(
                                typeof(RenderedList),
                                typeof(ofFragment),
                                typeof(Nested2)), Throws.InstanceOf <ArgumentException>());
            }

Example #23

File: ParserTests.cs Project: phosphene47/ofreact

        public void FlattenedLists()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(@"
render:
  - - - - - - Fragment:
  - Fragment:"));

            node.Diagnostics.EnsureRendered(typeof(ofYamlComponent), typeof(ofFragment), typeof(ofFragment), typeof(ofFragment));
        }

Example #24

File: ArrayPropTests.cs Project: phosphene47/ofreact

        public void StringArrayProp()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(@"
render:
  StringArrayPropElement:
    values:
      - value 1
      - value 2
      -"));
        }

Example #25

File: FragmentTests.cs Project: phosphene47/ofreact

        public void EmptyFragment()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(@"
render:
  Fragment:"));

            node.Diagnostics.EnsureRendered(
                typeof(ofYamlComponent),
                typeof(ofFragment));
        }

Example #26

File: RenderingTests.cs Project: phosphene47/ofreact

        public void RenderIfDifferentProps()
        {
            var node = new ofRootNode {
                AlwaysInvalid = false
            };                                                   // we don't want optimization

            node.RenderElement(new RenderIfDifferentPropsElement("test1"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(1));

            node.RenderElement(new RenderIfDifferentPropsElement("test2"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(2));

            node.RenderElement(new RenderIfDifferentPropsElement("test2"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(2));

            node.RenderElement(new RenderIfDifferentPropsElement("test2"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(2));

            node.RenderElement(new RenderIfDifferentPropsElement("test1"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(3));

            node.RenderElement(new RenderIfDifferentPropsElement("test1"));

            Assert.That(RenderIfDifferentPropsElement.RenderCount, Is.EqualTo(3));
        }

Example #27

File: RenderDiagnosticsTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                node.Diagnostics.EnsureRendered(
                    typeof(RenderedList),
                    typeof(ofFragment),
                    typeof(Nested1),
                    typeof(Nested1.Nested3),
                    typeof(Nested2));
            }

Example #28

File: UseContextTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                using var node = new ofRootNode();

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(1));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(2));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(3));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(1));
                Assert.That(Nested2Rendered, Is.EqualTo(4));

                RemoveNested2 = true;

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(2));
                Assert.That(Nested2Rendered, Is.EqualTo(4));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(2));
                Assert.That(Nested2Rendered, Is.EqualTo(4));

                RemoveNested2 = false;

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(3));
                Assert.That(Nested2Rendered, Is.EqualTo(5));

                node.RenderElement(this);

                Assert.That(Nested1Rendered, Is.EqualTo(3));
                Assert.That(Nested2Rendered, Is.EqualTo(6));
            }

Example #29

File: UseContextTests.cs Project: phosphene47/ofreact

            public void Test()
            {
                var node = new ofRootNode();

                Assert.That(Disposed, Is.False);

                node.RenderElement(this);

                Assert.That(Disposed, Is.False);

                node.Dispose();

                Assert.That(Disposed, Is.True);
            }

Example #30

File: ArrayPropTests.cs Project: phosphene47/ofreact

        public void StringJaggedArrayProp()
        {
            using var node = new ofRootNode();

            node.RenderElement(new ofYamlComponent(@"
render:
  StringJaggedArrayPropElement:
    values:
      - - value 1 1
        - value 1 2
      - - value 2 1
        - value 2 2
        - value 2 3
      -"));
        }