public void CanReadDoubleWithPercentSign()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <NumberTestExampe1>();

            originalData.Add(new NumberTestExampe1 {
                Id = 1, DoubleValue = "56.1%"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 2, DoubleValue = "-45.2%"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 3, DoubleValue = "123%"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <NumberTestExampe1, NumberTestExampe2>();
            List <NumberTestExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, false);


            // Assert
            // Assert
            // Assert
            CompareDoubleValue(actualList, 1, .561d);
            CompareDoubleValue(actualList, 2, -.452d);
            CompareDoubleValue(actualList, 3, 1.23d);
        }
        public void CanReadDecimalWithExponentNotation()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <NumberTestExampe1>();

            originalData.Add(new NumberTestExampe1 {
                Id = 1, DecimalValue = "123.30"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 2, DecimalValue = "-1.6530975699424744E-8"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 3, DecimalValue = "1.6530E+5"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <NumberTestExampe1, NumberTestExampe2>();
            List <NumberTestExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, false);


            // Assert
            // Assert
            // Assert
            CompareDecimalValue(actualList, 1, 123.30m);
            CompareDecimalValue(actualList, 2, -.000000016530975699424744m);
            CompareDecimalValue(actualList, 3, 165300.00m);
        }
        public void We_get_do_not_get_a_header_column_missing_errors_when_we_use_ClassToExcelAttribute_IsOptional()
        {
            // Arrange
            // Arrange
            // Arrange
            _messages.Clear();
            var originalData = new List <OptionalTestsExampe1>();

            originalData.Add(new OptionalTestsExampe1 {
                Id = 1, LastName = "McMasters"
            });
            originalData.Add(new OptionalTestsExampe1 {
                Id = 2, LastName = "Jones"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <OptionalTestsExampe1, OptionalTestsExampe2>();
            List <OptionalTestsExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, true, LogMessage, LogMessage);


            // Assert
            // Assert
            // Assert
            Assert.IsFalse(
                _messages.Any(
                    w => w.MessageType == ClassToExcelMessageType.HeaderProblem && w.ColumnName == "First Name"),
                "We should not have any header problems listed because the 'First Name' column is marked as optional!");
        }
        public void When_Ignore_is_used_with_the_ClassToExcelAttribute_data_is_not_read_from_the_file()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <IgnoreTestsExampe2>();

            originalData.Add(new IgnoreTestsExampe2 {
                Id = 1, Name = "Some Name"
            });
            originalData.Add(new IgnoreTestsExampe2 {
                Id = 2, Name = "Some Other Name"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <IgnoreTestsExampe2, IgnoreTestsExampe1>();
            List <IgnoreTestsExampe1> actualList = saveAndReadHelper.SaveAndRead(originalData, true);


            // Assert
            // Assert
            // Assert
            IgnoreTestsExampe1 data1 = actualList.FirstOrDefault(w => w.Id == 1);

            Assert.IsNotNull(data1, "Unable to find Id == 1 so data was not written properly");
            Assert.IsTrue(string.IsNullOrEmpty(data1.Name));
            IgnoreTestsExampe1 data2 = actualList.FirstOrDefault(w => w.Id == 2);

            Assert.IsNotNull(data2, "Unable to find Id == 2 so data was not written properly");
            Assert.IsTrue(string.IsNullOrEmpty(data2.Name));
        }
Exemplo n.º 5
0
        public void CanReadAndWriteRandomChickenDataWithNoHeaders()
        {
            const bool hasHeaderRow = false;

            // Arrange
            List <Chicken> expectedList = ChickenCreator.Work(20);

            // Act
            var saveAndReadHelper = new SaveAndReadHelper <Chicken, Chicken>();
            var actualList        = saveAndReadHelper.SaveAndRead(expectedList, hasHeaderRow);

            // Assert
            ChickenHelper.CompareExpectedWithActualAndAssertIfNotEqual(expectedList, actualList);
        }
Exemplo n.º 6
0
        public void CanReadAndWriteRandomPersonDataWithHeaders()
        {
            const bool hasHeaderRow = true;

            // Arrange
            List <Person> expectedList = PersonCreator.Work(20);

            // Act
            var saveAndReadHelper = new SaveAndReadHelper <Person, Person>();
            var actualList        = saveAndReadHelper.SaveAndRead(expectedList, hasHeaderRow);

            // Assert
            PersonHelper.CompareExpectedWithActualAndAssertIfNotEqual(expectedList, actualList);
        }
        public void Object_properties_are_ignored()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <IgnoreTestsExampe4>();

            originalData.Add(new IgnoreTestsExampe4 {
                Id = 1, Name = "Random Name 1", Owner = new IgnoreTestsExampe1()
                {
                    Id = 4, Name = "Owner dude"
                }
            });
            originalData.Add(new IgnoreTestsExampe4 {
                Id = 2, Name = "Random Name 2", Owner = new IgnoreTestsExampe1()
                {
                    Id = 5, Name = "Owner dude3"
                }
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <IgnoreTestsExampe4, IgnoreTestsExampe4>();
            List <IgnoreTestsExampe4> actualList = saveAndReadHelper.SaveAndRead(originalData, true);


            // Assert
            // Assert
            // Assert
            IgnoreTestsExampe4 data1 = actualList.FirstOrDefault(w => w.Id == 1);

            Assert.IsNotNull(data1, "Unable to find Id == 1 so data was not written properly");
            Assert.AreEqual("Random Name 1", data1.Name);
            Assert.IsNull(data1.Owner);
            IgnoreTestsExampe4 data2 = actualList.FirstOrDefault(w => w.Id == 2);

            Assert.IsNotNull(data2, "Unable to find Id == 2 so data was not written properly");
            Assert.AreEqual("Random Name 2", data2.Name);
            Assert.IsNull(data2.Owner);
        }
        public void PropertyNames_do_not_need_to_match_if_ClassToExcelAttribute_ColumnName_is_specified_and_the_file_contains_a_header_row()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <ColumnNameTestsExampe1>();

            originalData.Add(new ColumnNameTestsExampe1 {
                Id = 1, FName = "Tom", LName = "McMasters"
            });
            originalData.Add(new ColumnNameTestsExampe1 {
                Id = 2, FName = "David", LName = "Jones"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <ColumnNameTestsExampe1, ColumnNameTestsExampe2>();
            List <ColumnNameTestsExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, true);


            // Assert
            // Assert
            // Assert
            ColumnNameTestsExampe1 expected1 = originalData.FirstOrDefault(w => w.Id == 1);
            ColumnNameTestsExampe2 actual1   = actualList.FirstOrDefault(w => w.Id == 1);

            Assert.IsNotNull(actual1, "Unable to find Id == 1 so data was not written properly");
            Assert.AreEqual(expected1.FName, actual1.FirstName, "Expected first name to be equal!");
            Assert.AreEqual(expected1.LName, actual1.LastName, "Expected last name to be equal!");

            ColumnNameTestsExampe1 expected2 = originalData.FirstOrDefault(w => w.Id == 2);
            ColumnNameTestsExampe2 actual2   = actualList.FirstOrDefault(w => w.Id == 2);

            Assert.IsNotNull(actual2, "Unable to find Id == 2 so data was not written properly");
            Assert.AreEqual(expected2.FName, actual2.FirstName, "Expected first name to be equal!");
            Assert.AreEqual(expected2.LName, actual2.LastName, "Expected last name to be equal!");
        }
Exemplo n.º 9
0
        public void When_a_header_is_present_the_ClassToExcelAttribute_ColumnName_takes_priority_over_Order()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <OrderTestsExampe1>();

            originalData.Add(new OrderTestsExampe1 {
                Id = 1, FirstName = "Tom", LastName = "McMasters"
            });
            originalData.Add(new OrderTestsExampe1 {
                Id = 2, FirstName = "David", LastName = "Jones"
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <OrderTestsExampe1, OrderTestsExampe2>();
            List <OrderTestsExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, true);


            // Assert
            // Assert
            // Assert
            OrderTestsExampe1 expected1 = originalData.FirstOrDefault(w => w.Id == 1);
            OrderTestsExampe2 actual1   = actualList.FirstOrDefault(w => w.Id == 1);

            Assert.IsNotNull(actual1, "Unable to find Id == 1 so data was not written properly");
            Assert.AreEqual(expected1.FirstName, actual1.FirstName, "Expected first name to be equal!");
            Assert.AreEqual(expected1.LastName, actual1.LastName, "Expected last name to be equal!");

            OrderTestsExampe1 expected2 = originalData.FirstOrDefault(w => w.Id == 2);
            OrderTestsExampe2 actual2   = actualList.FirstOrDefault(w => w.Id == 2);

            Assert.IsNotNull(actual2, "Unable to find Id == 2 so data was not written properly");
            Assert.AreEqual(expected2.FirstName, actual2.FirstName, "Expected first name to be equal!");
            Assert.AreEqual(expected2.LastName, actual2.LastName, "Expected last name to be equal!");
        }
Exemplo n.º 10
0
        public void CanReadDoubles()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <NumberTestExampe1>();

            originalData.Add(new NumberTestExampe1 {
                Id = 1, DoubleValue = "123.30"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 2, DoubleValue = "-124.67"
            });
            // To round-trip the double, using "R" option
            // http://www.hanselman.com/blog/WhyYouCantDoubleParseDoubleMaxValueToStringOrSystemOverloadExceptionsWhenUsingDoubleParse.aspx
            originalData.Add(new NumberTestExampe1 {
                Id = 3, DoubleValue = double.MaxValue.ToString("R")
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 4, DoubleValue = double.MinValue.ToString("R")
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <NumberTestExampe1, NumberTestExampe2>();
            List <NumberTestExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, false);


            // Assert
            // Assert
            // Assert
            CompareDoubleValue(actualList, 1, 123.30d);
            CompareDoubleValue(actualList, 2, -124.67d);
            CompareDoubleValue(actualList, 3, double.MaxValue);
            CompareDoubleValue(actualList, 4, double.MinValue);
        }
Exemplo n.º 11
0
        public void CanReadDecimals()
        {
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <NumberTestExampe1>();

            originalData.Add(new NumberTestExampe1 {
                Id = 1, DecimalValue = "123.30"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 2, DecimalValue = "-123.54"
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 3, DecimalValue = Decimal.MaxValue.ToString()
            });
            originalData.Add(new NumberTestExampe1 {
                Id = 4, DecimalValue = Decimal.MinValue.ToString()
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <NumberTestExampe1, NumberTestExampe2>();
            List <NumberTestExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, false);


            // Assert
            // Assert
            // Assert
            CompareDecimalValue(actualList, 1, 123.30m);
            CompareDecimalValue(actualList, 2, -123.54m);
            CompareDecimalValue(actualList, 3, decimal.MaxValue);
            CompareDecimalValue(actualList, 4, decimal.MinValue);
        }
Exemplo n.º 12
0
        public void When_data_has_a_private_setter_data_is_written_to_the_file()
        {
            // If you want to ignore a property, users should use the Ignore property on the ClassToExcelAttribute
            // I'm testing this because the reader and writer use the same base class method for reflecting over properties.
            // Arrange
            // Arrange
            // Arrange
            var originalData = new List <IgnoreTestsExampe3>();

            originalData.Add(new IgnoreTestsExampe3 {
                Id = 1
            });
            originalData.Add(new IgnoreTestsExampe3 {
                Id = 2
            });

            // Act
            // Act
            // Act
            // Using a different class with similar properties WITHOUT the ignore attribute to prove that nothing was truly written
            // if we used the same class the reader would not even look for the Name field.
            var saveAndReadHelper = new SaveAndReadHelper <IgnoreTestsExampe3, IgnoreTestsExampe2>();
            List <IgnoreTestsExampe2> actualList = saveAndReadHelper.SaveAndRead(originalData, true);


            // Assert
            // Assert
            // Assert
            IgnoreTestsExampe2 data1 = actualList.FirstOrDefault(w => w.Id == 1);

            Assert.IsNotNull(data1, "Unable to find Id == 1 so data was not written properly");
            Assert.AreEqual("Some Name", data1.Name);
            IgnoreTestsExampe2 data2 = actualList.FirstOrDefault(w => w.Id == 2);

            Assert.IsNotNull(data2, "Unable to find Id == 2 so data was not written properly");
            Assert.AreEqual("Some Name", data2.Name);
        }