diff options
Diffstat (limited to 'ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping')
7 files changed, 759 insertions, 0 deletions
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs new file mode 100644 index 0000000..6e9cd89 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/AutoMappingTests.cs @@ -0,0 +1,394 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading; +using CsvHelper.Configuration; +using Xunit; + +namespace CsvHelper.Tests.AutoMapping +{ + public class AutoMappingTests + { + public AutoMappingTests() + { + Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); + } + + [Fact] + public void ReaderSimpleTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture)) + { + writer.WriteLine("Id,Name"); + writer.WriteLine("1,one"); + writer.WriteLine("2,two"); + writer.Flush(); + stream.Position = 0; + + var list = csv.GetRecords<Simple>().ToList(); + + Assert.NotNull(list); + Assert.Equal(2, list.Count); + var row = list[0]; + Assert.Equal(1, row.Id); + Assert.Equal("one", row.Name); + row = list[1]; + Assert.Equal(2, row.Id); + Assert.Equal("two", row.Name); + } + } + + [Fact] + public void ReaderFloatingCultureDeTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvReader(reader, CultureInfo.GetCultureInfo("de-DE"))) + { + writer.WriteLine("Single;Double;Decimal"); + writer.WriteLine("1,1;+0000002,20;3,30000"); + writer.WriteLine("-0,1;-0,2;-,3"); + writer.Flush(); + stream.Position = 0; + + var list = csv.GetRecords<Numbers>().ToList(); + + Assert.NotNull(list); + Assert.Equal(2, list.Count); + var row = list[0]; + Assert.Equal(1.1f, row.Single, 4); + Assert.Equal(2.2d, row.Double, 4); + Assert.Equal(3.3m, row.Decimal); + + row = list[1]; + Assert.Equal(-0.1f, row.Single, 4); + Assert.Equal(-0.2d, row.Double, 4); + Assert.Equal(-0.3m, row.Decimal); + } + } + + [Fact] + public void ReaderReferenceTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture)) + { + writer.WriteLine("AId,BId"); + writer.WriteLine("1,2"); + writer.Flush(); + stream.Position = 0; + + var list = csv.GetRecords<A>().ToList(); + + Assert.NotNull(list); + Assert.Single(list); + var row = list[0]; + Assert.Equal(1, row.AId); + Assert.NotNull(row.B); + Assert.Equal(2, row.B.BId); + } + } + + [Fact] + public void ReaderReferenceHasNoDefaultConstructorTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => args.Header.ToLower(), + }; + var s = new StringBuilder(); + s.AppendLine("Id,Name"); + s.AppendLine("1,one"); + using (var csv = new CsvReader(new StringReader(s.ToString()), config)) + { + var records = csv.GetRecords<SimpleReferenceHasNoDefaultConstructor>().ToList(); + var row = records[0]; + Assert.Equal(1, row.Id); + Assert.Equal("one", row.Ref.Name); + } + } + + [Fact] + public void ReaderHasNoDefaultConstructorReferenceHasNoDefaultConstructorTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => args.Header.ToLower(), + }; + var s = new StringBuilder(); + s.AppendLine("Id,Name"); + s.AppendLine("1,one"); + using (var csv = new CsvReader(new StringReader(s.ToString()), config)) + { + var records = csv.GetRecords<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor>().ToList(); + var row = records[0]; + Assert.Equal(1, row.Id); + Assert.Equal("one", row.Ref.Name); + } + } + + [Fact] + public void WriterSimpleTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<Simple> + { + new Simple { Id = 1, Name = "one" } + }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var data = reader.ReadToEnd(); + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("Id,Name"); + expected.AppendLine("1,one"); + + Assert.Equal(expected.ToString(), data); + } + } + + [Fact] + public void WriterReferenceTest() + { + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<A> + { + new A + { + AId = 1, + B = new B + { + BId = 2 + } + } + }; + csv.WriteRecords(list); + writer.Flush(); + stream.Position = 0; + + var data = reader.ReadToEnd(); + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("AId,BId"); + expected.AppendLine("1,2"); + + Assert.Equal(expected.ToString(), data); + } + } + + [Fact] + public void WriterReferenceHasNoDefaultConstructorTest() + { + using (var writer = new StringWriter()) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<SimpleReferenceHasNoDefaultConstructor> + { + new SimpleReferenceHasNoDefaultConstructor + { + Id = 1, + Ref = new NoDefaultConstructor( "one" ) + } + }; + csv.WriteRecords(list); + writer.Flush(); + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("Id,Name"); + expected.AppendLine("1,one"); + + Assert.Equal(expected.ToString(), writer.ToString()); + } + } + + [Fact] + public void WriterHasNoDefaultConstructorReferenceHasNoDefaultConstructorTest() + { + using (var writer = new StringWriter()) + using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) + { + var list = new List<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor> + { + new SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor(1, new NoDefaultConstructor("one")) + }; + csv.WriteRecords(list); + writer.Flush(); + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("Id,Name"); + expected.AppendLine("1,one"); + + Assert.Equal(expected.ToString(), writer.ToString()); + } + } + + [Fact] + public void AutoMapEnumerableTest() + { + var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture)); + + Assert.Throws<ConfigurationException>(() => context.AutoMap(typeof(List<string>))); + } + + [Fact] + public void AutoMapWithExistingMapTest() + { + var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture)); + var existingMap = new SimpleMap(); + context.Maps.Add(existingMap); + var data = new + { + Simple = new Simple + { + Id = 1, + Name = "one" + } + }; + var map = context.AutoMap(data.GetType()); + + Assert.NotNull(map); + Assert.Empty(map.MemberMaps); + Assert.Single(map.ReferenceMaps); + + // Since Simple is a reference on the anonymous object, the type won't + // be re-used. Types which are created from automapping aren't added + // to the list of registered maps either. + Assert.IsNotType<SimpleMap>(map.ReferenceMaps[0].Data.Mapping); + } + + [Fact] + public void AutoMapWithNestedHeaders() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture) + { + ReferenceHeaderPrefix = args => $"{args.MemberName}." + }; + var context = new CsvContext(config); + var map = context.AutoMap<Nested>(); + Assert.Equal("Simple1.Id", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]); + Assert.Equal("Simple1.Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[1].Data.Names[0]); + Assert.Equal("Simple2.Id", map.ReferenceMaps[1].Data.Mapping.MemberMaps[0].Data.Names[0]); + Assert.Equal("Simple2.Name", map.ReferenceMaps[1].Data.Mapping.MemberMaps[1].Data.Names[0]); + } + + [Fact] + public void AutoMapWithDefaultConstructor() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); + var context = new CsvContext(config); + ClassMap map = context.AutoMap<SimpleReferenceHasNoDefaultConstructor>(); + + Assert.Equal("Id", map.MemberMaps[0].Data.Names[0]); + Assert.Equal("Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]); + Assert.Equal("name", map.ReferenceMaps[0].Data.Mapping.ParameterMaps[0].Data.Names[0]); + } + + [Fact] + public void AutoMapWithNoDefaultConstructor() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); + var context = new CsvContext(config); + var map = context.AutoMap<SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor>(); + + Assert.Equal("Id", map.MemberMaps[0].Data.Names[0]); + Assert.Equal("id", map.ParameterMaps[0].Data.Names[0]); + Assert.Equal("name", map.ParameterMaps[1].ConstructorTypeMap.ParameterMaps[0].Data.Names[0]); + Assert.Equal("Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]); + Assert.Equal("name", map.ReferenceMaps[0].Data.Mapping.ParameterMaps[0].Data.Names[0]); + } + + private class Nested + { + public Simple Simple1 { get; set; } + + public Simple Simple2 { get; set; } + } + + private class Simple + { + public int Id { get; set; } + + public string Name { get; set; } + } + + private sealed class SimpleMap : ClassMap<Simple> + { + public SimpleMap() + { + Map(m => m.Id); + Map(m => m.Name); + } + } + + private class Numbers + { + public float Single { get; set; } + public double Double { get; set; } + public decimal Decimal { get; set; } + } + + private class A + { + public int AId { get; set; } + + public B B { get; set; } + } + + private class B + { + public int BId { get; set; } + } + + private class SimpleReferenceHasNoDefaultConstructor + { + public int Id { get; set; } + + public NoDefaultConstructor Ref { get; set; } + } + + private class SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor + { + public int Id { get; set; } + + public NoDefaultConstructor Ref { get; set; } + + public SimpleHasNoDefaultConstructorReferenceHasNoDefaultConstructor(int id, NoDefaultConstructor ref_) + { + Id = id; + Ref = ref_; + } + } + + private class NoDefaultConstructor + { + public string Name { get; set; } + + public NoDefaultConstructor(string name) + { + Name = name; + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs new file mode 100644 index 0000000..52118f3 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/BaseClassTests.cs @@ -0,0 +1,52 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using Xunit; +using System.Globalization; +using System.IO; +using System.Text; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class BaseClassTests + { + [Fact] + public void EnsureChildNotWrittenWhenListIsParent() + { + var record = new Child + { + ChildProp = "child", + ParentProp = "parent" + }; + Parent[] records = { record }; + + using( var stream = new MemoryStream() ) + using( var writer = new StreamWriter( stream ) ) + using( var reader = new StreamReader( stream ) ) + using( var csv = new CsvWriter(writer, CultureInfo.InvariantCulture) ) + { + csv.WriteRecords( records ); + writer.Flush(); + stream.Position = 0; + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine( "ParentProp" ); + expected.AppendLine( "parent" ); + + Assert.Equal( expected.ToString(), reader.ReadToEnd() ); + } + } + + private class Parent + { + public string ParentProp { get; set; } + } + + private class Child : Parent + { + public string ChildProp { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs new file mode 100644 index 0000000..0ae94e7 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/CircularReferenceTests.cs @@ -0,0 +1,98 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using Xunit; +using System.Globalization; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class CircularReferenceTests + { + [Fact] + public void SelfCircularDependencyTest() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); + var context = new CsvContext(config); + var map = context.AutoMap<SelfCircularA>(); + } + + [Fact] + public void CircularDependencyTest() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); + var context = new CsvContext(config); + var map = context.AutoMap<ACircular>(); + Assert.NotNull(map); + Assert.Single(map.MemberMaps); + Assert.Single(map.ReferenceMaps); + Assert.Single(map.ReferenceMaps[0].Data.Mapping.MemberMaps); + Assert.Empty(map.ReferenceMaps[0].Data.Mapping.ReferenceMaps); + } + + [Fact] + public void CircularDependencyWithMultiplePropertiesTest() + { + var config = new CsvHelper.Configuration.CsvConfiguration(CultureInfo.InvariantCulture); + var context = new CsvContext(config); + var map = context.AutoMap<A>(); + Assert.Single(map.MemberMaps); + Assert.Equal(3, map.ReferenceMaps.Count); + } + + private class SelfCircularA + { + public SelfCircularB Circular { get; set; } + } + + private class SelfCircularB + { + public SelfCircularB Self { get; set; } + + public SelfCircularC C { get; set; } + } + + private class SelfCircularC + { + public string Id { get; set; } + } + + private class ACircular + { + public string Id { get; set; } + + public BCircular B { get; set; } + } + + private class BCircular + { + public string Id { get; set; } + + public ACircular A { get; set; } + } + + private class A + { + public string Id { get; set; } + + public B B1 { get; set; } + + public B B2 { get; set; } + + public B B3 { get; set; } + } + + private class B + { + public string Id { get; set; } + + public C C { get; set; } + } + + private class C + { + public string Id { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs new file mode 100644 index 0000000..2e41972 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/ContextTests.cs @@ -0,0 +1,36 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using CsvHelper.Configuration; +using Xunit; +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class ContextTests + { + [Fact] + public void AutoMap_UsesContext() + { + var context = new CsvContext(new CsvConfiguration(CultureInfo.InvariantCulture)); + context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add("Bar"); + + var map = context.AutoMap<Foo>(); + + Assert.Contains("Bar", map.MemberMaps.Find<Foo>(x => x.Name).Data.TypeConverterOptions.NullValues); + } + + private class Foo + { + public int Id { get; set; } + public string Name { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs new file mode 100644 index 0000000..bc9e8b2 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/IgnoreReferencesTests.cs @@ -0,0 +1,62 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using CsvHelper.Configuration; +using Xunit; +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class IgnoreReferencesTests + { + [Fact] + public void IgnoreReferncesWritingTest() + { + var records = new List<Foo> + { + new Foo + { + Id = 1, + Bar = new Bar { Name = "one" } + } + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IgnoreReferences = true, + }; + using (var writer = new StringWriter()) + using (var csv = new CsvWriter(writer, config)) + { + csv.WriteRecords(records); + writer.Flush(); + + var expected = new TestStringBuilder(csv.Configuration.NewLine); + expected.AppendLine("Id"); + expected.AppendLine("1"); + + Assert.Equal(expected.ToString(), writer.ToString()); + } + } + + private class Foo + { + public int Id { get; set; } + + public Bar Bar { get; set; } + } + + private class Bar + { + public string Name { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs new file mode 100644 index 0000000..f244505 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/MappingTypeOfTypeTest.cs @@ -0,0 +1,41 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using CsvHelper.Tests.Mocks; +using Xunit; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class MappingTypeOfTypeTest + { + [Fact] + public void ClassWithPropertyOfTypeTypeShouldNotCauseStackOverflowExceptionTest() + { + var parser = new ParserMock + { + { "Id" }, + { "1" }, + }; + + using (var csv = new CsvReader(parser)) + { + var records = csv.GetRecords<EquipmentDataPoint>().ToList(); + Assert.Single(records); + Assert.Equal(1, records[0].Id); + } + } + + public class EquipmentDataPoint + { + public int Id { get; set; } + + [CsvHelper.Configuration.Attributes.Ignore] + public Type ValueType { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs new file mode 100644 index 0000000..8ad3da9 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/AutoMapping/StructTests.cs @@ -0,0 +1,76 @@ +// Copyright 2009-2022 Josh Close +// This file is a part of CsvHelper and is dual licensed under MS-PL and Apache 2.0. +// See LICENSE.txt for details or visit http://www.opensource.org/licenses/ms-pl.html for MS-PL and http://opensource.org/licenses/Apache-2.0 for Apache 2.0. +// https://github.com/JoshClose/CsvHelper +using CsvHelper.Configuration; +using Xunit; +using System.Globalization; +using System.IO; +using System.Linq; + +namespace CsvHelper.Tests.AutoMapping +{ + + public class StructTests + { + [Fact] + public void StructTest() + { + using (var stream = new MemoryStream()) + using (var writer = new StreamWriter(stream)) + using (var reader = new StreamReader(stream)) + using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture)) + { + writer.WriteLine("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<B>().ToList(); + + Assert.Equal(1, records[0].Id); + Assert.Equal("one", records[0].Name); + } + } + + [Fact] + public void StructPropertyTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ReferenceHeaderPrefix = args => $"{args.MemberName}.", + }; + using (var stream = new MemoryStream()) + using (var writer = new StreamWriter(stream)) + using (var reader = new StreamReader(stream)) + using (var csv = new CsvReader(reader, config)) + { + writer.WriteLine("Simple1.Id,Simple1.Name,Simple2.Id,Simple2.Name,Title"); + writer.WriteLine("1,one,2,two,Works!"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<A>().ToList(); + + Assert.Equal(1, records[0].Simple1.Id); + Assert.Equal("one", records[0].Simple1.Name); + Assert.Equal(2, records[0].Simple2.Id); + Assert.Equal("two", records[0].Simple2.Name); + Assert.Equal("Works!", records[0].Title); + } + } + + public class A + { + public B Simple1 { get; set; } + public string Title { get; set; } + public B Simple2 { get; set; } + } + + public struct B + { + public int Id { get; set; } + public string Name { get; set; } + } + } +} |