Example #1
0
        public void TestExcelMapperConvertException()
        {
            ExcelMapperConvertException ex =
                new ExcelMapperConvertException("cellvalue", typeof(string), 12, 34);

            // Sanity check: Make sure custom properties are set before serialization
            Assert.AreEqual(12, ex.Line);
            Assert.AreEqual(34, ex.Column);

            // Round-trip the exception: Serialize and de-serialize with a BinaryFormatter
            var bf = new BinaryFormatter();

            using (var ms = new MemoryStream())
            {
                // "Save" object state
                bf.Serialize(ms, ex);

                // Re-use the same stream for de-serialization
                ms.Seek(0, 0);

                // Replace the original exception with de-serialized one
                ex = (ExcelMapperConvertException)bf.Deserialize(ms);
            }

            // Make sure custom properties are preserved after serialization
            Assert.AreEqual(12, ex.Line);
            Assert.AreEqual(34, ex.Column);

            Assert.Throws <ArgumentNullException>(() => ex.GetObjectData(null, new System.Runtime.Serialization.StreamingContext()));
        }
        public void MessageConstructorTest()
        {
            const string message = "Exception message.";

            var ex = new ExcelMapperConvertException(message);

            Assert.AreEqual(message, ex.Message);
        }
        public void MessageAndInnerExceptionConstructorTest()
        {
            const string message = "Exception message.";
            var          baseEx  = new StackOverflowException();

            var ex = new ExcelMapperConvertException(message, baseEx);

            Assert.AreEqual(message, ex.Message);
            Assert.AreEqual(baseEx.GetType(), ex.InnerException?.GetType());
        }
        public void ParamsConstructorTest()
        {
            const string value      = "test";
            var          targetType = typeof(int);
            const int    line       = 1;
            const int    column     = 2;

            var ex = new ExcelMapperConvertException(value, targetType, line, column);

            Assert.AreEqual(value, ex.CellValue);
            Assert.AreEqual(targetType, ex.TargetType);
            Assert.AreEqual(line, ex.Line);
            Assert.AreEqual(column, ex.Column);
            Assert.That(ex.Message.Contains($"\"{value}\""));
            Assert.That(ex.Message.Contains(targetType.ToString()));
            Assert.That(ex.Message.Contains($"[L:{line}]"));
            Assert.That(ex.Message.Contains($"[C:{column}]"));
        }
        public void EmptyConstructorTest()
        {
            var ex = new ExcelMapperConvertException();

            Assert.NotNull(ex);
        }
        public void EmptyConstructorTest()
        {
            var ex = new ExcelMapperConvertException();

            Assert.AreEqual($"Exception of type '{typeof(ExcelMapperConvertException).FullName}' was thrown.", ex.Message);
        }