Ejemplo n.º 1
0
        public void StringDictionary()
        {
            // Arrange
            var expected = new RecursiveData { Array = new[] { 1, 2, 3, } };
            var dict = new Dictionary<string, string>() { { "Array", string.Join(";", expected.Array) } };

            // Act
            var actual = dict.ToObjectSafe<RecursiveData>();

            // Assert
            CollectionAssert.AreEqual(expected.Array, actual.Array);
        }
Ejemplo n.º 2
0
        public void LengthyTest()
        {
            var expected = new RecursiveData
            {
                Id = new Guid("366f4bd3-6717-4b14-9c79-70515296df7e"),
                Date = new DateTime(1999, 1, 1),
                Enum = Enumeration.One,
                Text = "level 1",
                Array = new[] { 1, 2, 3, },
                Nested = new RecursiveData
                {
                    Id = new Guid("e591be31-289f-4a99-ba67-288ea24b7d7e"),
                    Date = new DateTime(1999, 2, 2),
                    Enum = Enumeration.Two,
                    Text = "level 2",
                    Array = new[] { 4, 5, 6, },
                    Nested = new RecursiveData
                    {
                        Id = null,
                        Date = null,
                        Enum = null,
                        Text = null,
                        Nested = new RecursiveData
                        {
                            Id = new Guid("3bfdd62f-8b31-4aa2-931d-46535f291b0e"),
                            Date = new DateTime(1999, 4, 4),
                            Enum = Enumeration.Four,
                            Text = "level 4",
                            Array = new[] { 10, 11, 12, },
                            Nested = null,
                        },
                    },
                },
            };

            var dict =
                new Dictionary<string, object>()
                {
                    // 1st level
                    { "Id", expected.Id },
                    { "Date", expected.Date },
                    { "Enum", expected.Enum },
                    { "Text", expected.Text },
                    { "Array", expected.Array },

                    // 2nd level
                    { "Nested.Id", expected.Nested.Id },
                    { "Nested.Date", expected.Nested.Date },
                    { "Nested.Enum", expected.Nested.Enum },
                    { "Nested.Text", expected.Nested.Text },
                    { "Nested.Array", expected.Nested.Array },

                    // 3rd level
                    { "Nested.Nested.Id", expected.Nested.Nested.Id },
                    { "Nested.Nested.Date", expected.Nested.Nested.Date },
                    { "Nested.Nested.Enum", expected.Nested.Nested.Enum },
                    { "Nested.Nested.Text", expected.Nested.Nested.Text },
                    { "Nested.Nested.Array", expected.Nested.Nested.Array },

                    // 4th level
                    { "Nested.Nested.Nested.Id", expected.Nested.Nested.Nested.Id },
                    { "Nested.Nested.Nested.Date", expected.Nested.Nested.Nested.Date },
                    { "Nested.Nested.Nested.Enum", expected.Nested.Nested.Nested.Enum },
                    { "Nested.Nested.Nested.Text", expected.Nested.Nested.Nested.Text },
                    { "Nested.Nested.Nested.Array", expected.Nested.Nested.Nested.Array },

                    // 5th level
                    { "Nested.Nested.Nested.Nested.Id", null },
                    { "Nested.Nested.Nested.Nested.Date", null },
                    { "Nested.Nested.Nested.Nested.Enum", null },
                    { "Nested.Nested.Nested.Nested.Text", null },
                    { "Nested.Nested.Nested.Nested.Array", null },
                };

            var actual = dict.ToObject<RecursiveData>();

            // 1st level
            Assert.AreEqual(expected.Id, actual.Id);
            Assert.AreEqual(expected.Date, actual.Date);
            Assert.AreEqual(expected.Enum, actual.Enum);
            Assert.AreEqual(expected.Text, actual.Text);
            CollectionAssert.AreEqual(expected.Array, actual.Array);

            // 2nd level
            Assert.AreEqual(expected.Nested.Id, actual.Nested.Id);
            Assert.AreEqual(expected.Nested.Date, actual.Nested.Date);
            Assert.AreEqual(expected.Nested.Enum, actual.Nested.Enum);
            Assert.AreEqual(expected.Nested.Text, actual.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Array, actual.Nested.Array);

            // 3rd level
            Assert.AreEqual(expected.Nested.Nested.Id, actual.Nested.Nested.Id);
            Assert.AreEqual(expected.Nested.Nested.Date, actual.Nested.Nested.Date);
            Assert.AreEqual(expected.Nested.Nested.Enum, actual.Nested.Nested.Enum);
            Assert.AreEqual(expected.Nested.Nested.Text, actual.Nested.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Nested.Array, actual.Nested.Nested.Array);

            // 4th level
            Assert.AreEqual(expected.Nested.Nested.Nested.Id, actual.Nested.Nested.Nested.Id);
            Assert.AreEqual(expected.Nested.Nested.Nested.Date, actual.Nested.Nested.Nested.Date);
            Assert.AreEqual(expected.Nested.Nested.Nested.Enum, actual.Nested.Nested.Nested.Enum);
            Assert.AreEqual(expected.Nested.Nested.Nested.Text, actual.Nested.Nested.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Nested.Nested.Array, actual.Nested.Nested.Nested.Array);

            // 5th level
            Assert.AreEqual(null, actual.Nested.Nested.Nested.Nested);
        }
Ejemplo n.º 3
0
        public void LengthyTest()
        {
            var expected = new RecursiveData
            {
                Id = new Guid("366f4bd3-6717-4b14-9c79-70515296df7e"),
                Date = new DateTime(1999, 1, 1),
                Enum = Enumeration.One,
                Text = "level 1",
                Array = new[] { 1, 2, 3, },
                Nested = new RecursiveData
                {
                    Id = new Guid("e591be31-289f-4a99-ba67-288ea24b7d7e"),
                    Date = new DateTime(1999, 2, 2),
                    Enum = Enumeration.Two,
                    Text = "level 2",
                    Array = new[] { 4, 5, 6, },
                    Nested = new RecursiveData
                    {
                        Id = null,
                        Date = null,
                        Enum = null,
                        Text = null,
                        Array = null,
                        Nested = new RecursiveData
                        {
                            Id = new Guid("3bfdd62f-8b31-4aa2-931d-46535f291b0e"),
                            Date = new DateTime(1999, 4, 4),
                            Enum = Enumeration.Four,
                            Text = "level 4",
                            Array = new[] { 10, 11, 12, },
                            Nested = null,
                        },
                    },
                },
            };

            var table = new DataTable();

            // 1st level
            table.Columns.Add("Id", typeof(Guid));
            table.Columns.Add("Date", typeof(DateTime));
            table.Columns.Add("Enum", typeof(int));
            table.Columns.Add("Text", typeof(string));
            table.Columns.Add("Array", typeof(int[]));

            // 2nd level
            table.Columns.Add("Nested.Id", typeof(Guid));
            table.Columns.Add("Nested.Date", typeof(DateTime));
            table.Columns.Add("Nested.Enum", typeof(int));
            table.Columns.Add("Nested.Text", typeof(string));
            table.Columns.Add("Nested.Array", typeof(int[]));

            // 3rd level
            table.Columns.Add("Nested.Nested.Id", typeof(Guid));
            table.Columns.Add("Nested.Nested.Date", typeof(DateTime));
            table.Columns.Add("Nested.Nested.Enum", typeof(int));
            table.Columns.Add("Nested.Nested.Text", typeof(string));
            table.Columns.Add("Nested.Nested.Array", typeof(int[]));

            // 4th level
            table.Columns.Add("Nested.Nested.Nested.Id", typeof(Guid));
            table.Columns.Add("Nested.Nested.Nested.Date", typeof(DateTime));
            table.Columns.Add("Nested.Nested.Nested.Enum", typeof(int));
            table.Columns.Add("Nested.Nested.Nested.Text", typeof(string));
            table.Columns.Add("Nested.Nested.Nested.Array", typeof(int[]));

            // 5th level
            table.Columns.Add("Nested.Nested.Nested.Nested.Id", typeof(Guid));
            table.Columns.Add("Nested.Nested.Nested.Nested.Date", typeof(DateTime));
            table.Columns.Add("Nested.Nested.Nested.Nested.Enum", typeof(int));
            table.Columns.Add("Nested.Nested.Nested.Nested.Text", typeof(string));
            table.Columns.Add("Nested.Nested.Nested.Nested.Array", typeof(int[]));

            table.Rows.Add(

                // 1st level
                expected.Id,
                expected.Date,
                expected.Enum,
                expected.Text,
                expected.Array,

                // 2nd level
                expected.Nested.Id,
                expected.Nested.Date,
                expected.Nested.Enum,
                expected.Nested.Text,
                expected.Nested.Array,

                // 3rd level
                expected.Nested.Nested.Id,
                expected.Nested.Nested.Date,
                expected.Nested.Nested.Enum,
                expected.Nested.Nested.Text,
                expected.Nested.Nested.Array,

                // 4th level
                expected.Nested.Nested.Nested.Id,
                expected.Nested.Nested.Nested.Date,
                expected.Nested.Nested.Nested.Enum,
                expected.Nested.Nested.Nested.Text,
                expected.Nested.Nested.Nested.Array,

                // 5th level
                DBNull.Value,
                DBNull.Value,
                DBNull.Value,
                DBNull.Value,
                DBNull.Value
            );

            var actual = table.ToObject<RecursiveData>().Single();

            // 1st level
            Assert.AreEqual(expected.Id, actual.Id);
            Assert.AreEqual(expected.Date, actual.Date);
            Assert.AreEqual(expected.Enum, actual.Enum);
            Assert.AreEqual(expected.Text, actual.Text);
            CollectionAssert.AreEqual(expected.Array, actual.Array);

            // 2nd level
            Assert.AreEqual(expected.Nested.Id, actual.Nested.Id);
            Assert.AreEqual(expected.Nested.Date, actual.Nested.Date);
            Assert.AreEqual(expected.Nested.Enum, actual.Nested.Enum);
            Assert.AreEqual(expected.Nested.Text, actual.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Array, actual.Nested.Array);

            // 3rd level
            Assert.AreEqual(expected.Nested.Nested.Id, actual.Nested.Nested.Id);
            Assert.AreEqual(expected.Nested.Nested.Date, actual.Nested.Nested.Date);
            Assert.AreEqual(expected.Nested.Nested.Enum, actual.Nested.Nested.Enum);
            Assert.AreEqual(expected.Nested.Nested.Text, actual.Nested.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Nested.Array, actual.Nested.Nested.Array);

            // 4th level
            Assert.AreEqual(expected.Nested.Nested.Nested.Id, actual.Nested.Nested.Nested.Id);
            Assert.AreEqual(expected.Nested.Nested.Nested.Date, actual.Nested.Nested.Nested.Date);
            Assert.AreEqual(expected.Nested.Nested.Nested.Enum, actual.Nested.Nested.Nested.Enum);
            Assert.AreEqual(expected.Nested.Nested.Nested.Text, actual.Nested.Nested.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Nested.Nested.Array, actual.Nested.Nested.Nested.Array);

            // 5th level
            Assert.AreEqual(null, actual.Nested.Nested.Nested.Nested);
        }
Ejemplo n.º 4
0
        public void NestedDictionary()
        {
            var expected = new RecursiveData
            {
                Id = new Guid("366f4bd3-6717-4b14-9c79-70515296df7e"),
                Date = new DateTime(1999, 1, 1),
                Enum = Enumeration.One,
                Text = "level 1",
                Array = new[] { 1, 2, 3, },
                Nested = new RecursiveData
                {
                    Id = new Guid("e591be31-289f-4a99-ba67-288ea24b7d7e"),
                    Date = new DateTime(1999, 2, 2),
                    Enum = Enumeration.Two,
                    Text = "level 2",
                    Array = new[] { 4, 5, 6, },
                    Nested = null,
                },
            };

            var dict = new Dictionary<string, object>()
            {
                // 1st level
                { "Id", expected.Id },
                { "Date", expected.Date },
                { "Enum", expected.Enum },
                { "Text", expected.Text },
                { "Array", expected.Array },

                // 2nd level
                {
                    "Nested",
                    new Dictionary<string, object>
                    {
                        { "Id", expected.Nested.Id },
                        { "Date", expected.Nested.Date },
                        { "Enum", expected.Nested.Enum },
                        { "Text", expected.Nested.Text },
                        { "Array", expected.Nested.Array },
                        { "Nested", expected.Nested.Nested },
                    }
                }
            };

            var actual = dict.ToObject<RecursiveData>();

            // 1st level
            Assert.AreEqual(expected.Id, actual.Id);
            Assert.AreEqual(expected.Date, actual.Date);
            Assert.AreEqual(expected.Enum, actual.Enum);
            Assert.AreEqual(expected.Text, actual.Text);
            CollectionAssert.AreEqual(expected.Array, actual.Array);

            // 2nd level
            Assert.AreEqual(expected.Nested.Id, actual.Nested.Id);
            Assert.AreEqual(expected.Nested.Date, actual.Nested.Date);
            Assert.AreEqual(expected.Nested.Enum, actual.Nested.Enum);
            Assert.AreEqual(expected.Nested.Text, actual.Nested.Text);
            CollectionAssert.AreEqual(expected.Nested.Array, actual.Nested.Array);
        }