Example #1
0
        public void TestCreateFieldBuilder()
        {
            NodeDataListBuilder builder = new NodeDataListBuilder(Substitute.For <Type>());

            NodeData nodeData = new NodeData {
                name = "fieldbro"
            };
            IFieldWrapper  fieldWrapper = Substitute.For <IFieldWrapper>();
            IValueParseMap parseMap     = Substitute.For <IValueParseMap>();

            NodeDataBuilder fieldBuilder = Assert.IsType <NodeDataBuilder>(builder.CreateFieldBuilder(nodeData, fieldWrapper, parseMap));

            Assert.Same(nodeData, fieldBuilder.nodeData);
            Assert.Same(fieldWrapper, fieldBuilder.fieldWrapper);
            Assert.Same(parseMap, fieldBuilder.valueParseMap);
        }
        public void TestNew__UseParser()
        {
            Type type1 = typeof(DummyClass1);
            Type type2 = typeof(DummyClass2);
            Type type3 = typeof(DummyClass3);
            Type type4 = typeof(DummyClass4);

            IValueParser parser1 = Substitute.For <IValueParser>();
            IValueParser parser2 = Substitute.For <IValueParser>();
            IValueParser parser3 = Substitute.For <IValueParser>();

            parser1.ParseType.Returns(type1);
            parser2.ParseType.Returns(type2);

            IUseParser useParser1 = Substitute.For <IUseParser>();
            IUseParser useParser2 = Substitute.For <IUseParser>();

            useParser1.CreateParser().Returns(parser1);
            useParser2.CreateParser().Returns(parser2);

            parseMap.CanParse(type3).Returns(true);
            parseMap.CanParse(Arg.Is <Type>(y => y != type3)).Returns(false);

            parseMap.GetParser(type3).Returns(parser3);
            parseMap.When(x => x.GetParser(Arg.Is <Type>(y => y != type3))).Throw <Exception>();

            fieldWrapper.MemberInfo.GetCustomAttributes(true).Returns(new[] { useParser1, useParser2 });
            NodeDataBuilder builder2 = new NodeDataBuilder(nodeData, fieldWrapper, parseMap);

            OverrideValueParseMap newParseMap = Assert.IsType <OverrideValueParseMap>(builder2.valueParseMap);

            Assert.True(newParseMap.CanParse(type1));
            Assert.True(newParseMap.CanParse(type2));
            Assert.True(newParseMap.CanParse(type3));
            Assert.False(newParseMap.CanParse(type4));

            Assert.Same(parser1, newParseMap.GetParser(type1));
            Assert.Same(parser2, newParseMap.GetParser(type2));
            Assert.Same(parser3, newParseMap.GetParser(type3));
            Assert.Throws <Exception>(() => newParseMap.GetParser(type4));
        }
 public NodeDataBuilderTest()
 {
     builder = Substitute.ForPartsOf <NodeDataBuilder>(nodeData, fieldWrapper, parseMap);
 }