Ejemplo n.º 1
0
        public void WithInvalidFallbackItem_ValidFallbackItem_Success()
        {
            IFallbackItem fallback = new FixedValueFallback(10);
            SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value);

            Assert.Same(propertyMap, propertyMap.WithInvalidFallbackItem(fallback));

            Assert.Same(fallback, propertyMap.InvalidFallback);
        }
Ejemplo n.º 2
0
        public void WithEmptyFallbackItem_ValidFallbackItem_Success()
        {
            IFallbackItem        fallback    = new FixedValueFallback(10);
            OneToOneMap <string> propertyMap = Map(t => t.Value);

            Assert.Same(propertyMap, propertyMap.WithEmptyFallbackItem(fallback));

            Assert.Same(fallback, propertyMap.Pipeline.EmptyFallback);
        }
Ejemplo n.º 3
0
        public void WithInvalidFallback_Invoke_Success()
        {
            SingleExcelPropertyMap <string> propertyMap = Map(t => t.Value);

            Assert.Same(propertyMap, propertyMap.WithInvalidFallback("abc"));

            FixedValueFallback fallback = Assert.IsType <FixedValueFallback>(propertyMap.InvalidFallback);

            Assert.Equal("abc", fallback.Value);
        }
Ejemplo n.º 4
0
        public void WithEmptyFallback_Invoke_Success()
        {
            SingleExcelPropertyMap <string> mapping = Map(t => t.Value);

            Assert.Same(mapping, mapping.WithEmptyFallback("abc"));

            FixedValueFallback fallback = Assert.IsType <FixedValueFallback>(mapping.EmptyFallback);

            Assert.Equal("abc", fallback.Value);
        }
Ejemplo n.º 5
0
        public void Ctor_Default(object value)
        {
            var fallback = new FixedValueFallback(value);

            Assert.Same(value, value);

            object result = fallback.PerformFallback(null, 0, new ReadCellValueResult(), null);

            Assert.Same(value, result);
        }
Ejemplo n.º 6
0
        public void WithEmptyFallback_Invoke_Success()
        {
            OneToOneMap <string> propertyMapping = Map(t => t.Value);

            Assert.Same(propertyMapping, propertyMapping.WithEmptyFallback("abc"));

            FixedValueFallback fallback = Assert.IsType <FixedValueFallback>(propertyMapping.Pipeline.EmptyFallback);

            Assert.Equal("abc", fallback.Value);
        }
Ejemplo n.º 7
0
        public void WithValueFallback_Invoke_Success()
        {
            OneToOneMap <string> propertyMap = Map(t => t.Value);

            Assert.Same(propertyMap, propertyMap.WithValueFallback("abc"));

            FixedValueFallback emptyFallback   = Assert.IsType <FixedValueFallback>(propertyMap.Pipeline.EmptyFallback);
            FixedValueFallback invalidFallback = Assert.IsType <FixedValueFallback>(propertyMap.Pipeline.InvalidFallback);

            Assert.Equal("abc", emptyFallback.Value);
            Assert.Equal("abc", invalidFallback.Value);
        }
Ejemplo n.º 8
0
        public void InvalidFallback_Set_GetReturnsExpected()
        {
            var pipeline = new ValuePipeline();

            var fallback = new FixedValueFallback(10);

            pipeline.InvalidFallback = fallback;
            Assert.Same(fallback, pipeline.InvalidFallback);

            pipeline.InvalidFallback = null;
            Assert.Null(pipeline.InvalidFallback);
        }
Ejemplo n.º 9
0
        public void InvalidFallback_Set_GetReturnsExpected()
        {
            MemberInfo propertyInfo = typeof(TestClass).GetProperty(nameof(TestClass.Value));
            var        propertyMap  = new SingleExcelPropertyMap(propertyInfo);

            var fallback = new FixedValueFallback(10);

            propertyMap.InvalidFallback = fallback;
            Assert.Same(fallback, propertyMap.InvalidFallback);

            propertyMap.InvalidFallback = null;
            Assert.Null(propertyMap.InvalidFallback);
        }
Ejemplo n.º 10
0
        public void InvalidFallback_Set_GetReturnsExpected()
        {
            var reader = new ColumnNameValueReader("Column");
            var map    = new SubOneToOneMap <int>(reader);

            var fallback = new FixedValueFallback(10);

            map.InvalidFallback = fallback;
            Assert.Same(fallback, map.InvalidFallback);

            map.InvalidFallback = null;
            Assert.Null(map.InvalidFallback);
        }