diff options
Diffstat (limited to 'ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading')
16 files changed, 2763 insertions, 0 deletions
diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs new file mode 100644 index 0000000..79e537c --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/AnonymousTypesTests.cs @@ -0,0 +1,707 @@ +// 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.Reading +{ + + public class AnonymousTypesTests + { + [Fact] + public void ValueTypeSingleRecordTest() + { + var definition = new + { + Id = 0, + Name = string.Empty + }; + + 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; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + [Fact] + public void ValueTypeAllRecordsTest() + { + var definition = new + { + Id = 0, + Name = string.Empty + }; + + 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(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + [Fact] + public void ValueTypeAllRecordsNoHeaderTest() + { + var definition = new + { + Id = 0, + Name = string.Empty + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + + } + + [Fact] + public void ReferenceTypeSingleRecordTest() + { + var definition = new + { + Reference = new Test() + }; + + 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; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void ReferenceTypeAllRecordsTest() + { + var definition = new + { + Reference = new Test() + }; + + 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(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void ReferenceTypeAllRecordsNoHeaderTest() + { + var definition = new + { + Reference = new Test() + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void ValueAndReferenceTypeSingleRecordTest() + { + var definition = new + { + A = 0, + B = string.Empty, + Reference = new Test() + }; + + 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("A,Id,Name,B"); + writer.WriteLine("-1,1,one,b"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(-1, record.A); + Assert.Equal("b", record.B); + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void ValueAndReferenceTypeAllRecordsTest() + { + var definition = new + { + A = 0, + B = string.Empty, + Reference = new Test() + }; + + 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("A,Id,Name,B"); + writer.WriteLine("-1,1,one,b"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(-1, record.A); + Assert.Equal("b", record.B); + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void ValueAndReferenceTypeAllRecordsNoHeaderTest() + { + var definition = new + { + A = 0, + B = string.Empty, + Reference = new Test() + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("-1,b,1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(-1, record.A); + Assert.Equal("b", record.B); + Assert.Equal(1, record.Reference.Id); + Assert.Equal("one", record.Reference.Name); + } + } + + [Fact] + public void AnonymousReferenceSingleRecordTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + Name = string.Empty + } + }; + + 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; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.Name); + } + } + + [Fact] + public void AnonymousReferenceAllRecordsTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + Name = string.Empty + } + }; + + 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(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.Name); + } + } + + [Fact] + public void AnonymousReferenceAllRecordsNoHeaderTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + Name = string.Empty + } + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.Name); + } + } + + [Fact] + public void AnonymousReferenceHasAnonymousReferenceSingleRecordTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + AnonymousReference2 = new + { + Name = string.Empty + } + } + }; + + 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; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name); + } + } + + [Fact] + public void AnonymousReferenceHasAnonymousReferenceAllRecordsTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + AnonymousReference2 = new + { + Name = string.Empty + } + } + }; + + 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(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name); + } + } + + [Fact] + public void AnonymousReferenceHasAnonymousReferenceAllRecordsNoHeaderTest() + { + var definition = new + { + Id = 0, + AnonymousReference = new + { + AnonymousReference2 = new + { + Name = string.Empty + } + } + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.AnonymousReference.AnonymousReference2.Name); + } + } + + [Fact] + public void AnonymousReferenceHasReferenceSingleRecordTest() + { + var definition = new + { + A = 0, + AnonymousReference = new + { + Reference = new Test() + } + }; + + 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,A"); + writer.WriteLine("1,one,2"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(2, record.A); + Assert.Equal(1, record.AnonymousReference.Reference.Id); + Assert.Equal("one", record.AnonymousReference.Reference.Name); + } + } + + [Fact] + public void AnonymousReferenceHasReferenceAllRecordsTest() + { + var definition = new + { + A = 0, + AnonymousReference = new + { + Reference = new Test() + } + }; + + 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,A"); + writer.WriteLine("1,one,2"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(2, record.A); + Assert.Equal(1, record.AnonymousReference.Reference.Id); + Assert.Equal("one", record.AnonymousReference.Reference.Name); + } + } + + [Fact] + public void AnonymousReferenceHasReferenceAllRecordsNoHeaderTest() + { + var definition = new + { + A = 0, + AnonymousReference = new + { + Reference = new Test() + } + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("2,1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(2, record.A); + Assert.Equal(1, record.AnonymousReference.Reference.Id); + Assert.Equal("one", record.AnonymousReference.Reference.Name); + } + } + + [Fact] + public void ParentChildReferenceSingleRecordTest() + { + var definition = new + { + Reference = new Child() + }; + + 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("ParentId,ChildId,ParentName,ChildName"); + writer.WriteLine("1,2,one,two"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + var record = csv.GetRecord(definition); + + Assert.Equal(1, record.Reference.ParentId); + Assert.Equal("one", record.Reference.ParentName); + Assert.Equal(2, record.Reference.ChildId); + Assert.Equal("two", record.Reference.ChildName); + } + } + + [Fact] + public void ParentChildReferenceAllRecordsTest() + { + var definition = new + { + Reference = new Child() + }; + + 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("ParentId,ChildId,ParentName,ChildName"); + writer.WriteLine("1,2,one,two"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Reference.ParentId); + Assert.Equal("one", record.Reference.ParentName); + Assert.Equal(2, record.Reference.ChildId); + Assert.Equal("two", record.Reference.ChildName); + } + } + + [Fact] + public void ParentChildReferenceAllRecordsNoHeaderTest() + { + var definition = new + { + Reference = new Child() + }; + + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + 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("1,one,2,two"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords(definition).ToList(); + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Reference.ChildId); + Assert.Equal("one", record.Reference.ChildName); + Assert.Equal(2, record.Reference.ParentId); + Assert.Equal("two", record.Reference.ParentName); + } + } + + private class Test + { + public int Id { get; set; } + + public string Name { get; set; } + } + + private class ContainsReference + { + public Test Test { get; set; } + } + + private class Parent + { + public int ParentId { get; set; } + + public string ParentName { get; set; } + } + + private class Child : Parent + { + public int ChildId { get; set; } + + public string ChildName { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs new file mode 100644 index 0000000..b127478 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/BadDataTests.cs @@ -0,0 +1,64 @@ +using CsvHelper.Configuration; +using CsvHelper.Configuration.Attributes; +using System; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + public class BadDataTests + { + [Fact] + public void GetRecord_BadDataCountNotDuplicted() + { + var errorCount = 0; + var csvConfiguration = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ReadingExceptionOccurred = args => false, + BadDataFound = args => + { + ++errorCount; + }, + Delimiter = ";", + }; + var csv = "SKU;Min quantity;List price;Sale price\r\nTestSku1;2;10.99;9.99\r\nTestSku2;2;10.99;9\r\nXXX;\"9;10.9;9"; + var stream = new MemoryStream(); + using (var writer = new StreamWriter(stream, leaveOpen: true)) + { + writer.Write(csv); + writer.Flush(); + stream.Position = 0; + } + var textReader = new StreamReader(stream, leaveOpen: true); + + var csvReader = new CsvReader(textReader, csvConfiguration); + + while (csvReader.Read()) + { + csvReader.GetRecord<CsvPrice>(); + } + + Assert.Equal(1, errorCount); + } + + public sealed class CsvPrice + { + [Name("SKU")] + public string Sku { get; set; } + + [Name("Min quantity")] + public int MinQuantity { get; set; } + + [Name("List price")] + public decimal ListPrice { get; set; } + + [Name("Sale price")] + public decimal? SalePrice { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs new file mode 100644 index 0000000..9a9d3ac --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstantTests.cs @@ -0,0 +1,114 @@ +// 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.Linq; +using CsvHelper.Configuration; +using CsvHelper.Tests.Mocks; +using Xunit; +using System.IO; +using System.Globalization; + +namespace CsvHelper.Tests.Reading +{ + + public class ConstantTests + { + [Fact] + public void ConstantAlwaysReturnsSameValueTest() + { + var parser = new ParserMock + { + { "Id", "Name" }, + { "1", "one" }, + { "2", "two" }, + }; + + var csv = new CsvReader(parser); + csv.Context.RegisterClassMap<TestStringMap>(); + var records = csv.GetRecords<Test>().ToList(); + + Assert.Equal(1, records[0].Id); + Assert.Equal("constant", records[0].Name); + Assert.Equal(2, records[1].Id); + Assert.Equal("constant", records[1].Name); + } + + [Fact] + public void ConstantIsNullTest() + { + var rows = new Queue<string[]>(); + rows.Enqueue(new[] { "Id", "Name" }); + rows.Enqueue(new[] { "1", "one" }); + rows.Enqueue(new[] { "2", "two" }); + rows.Enqueue(null); + var parser = new ParserMock + { + { "Id", "Name" }, + { "1", "one" }, + { "2", "two" }, + }; + + var csv = new CsvReader(parser); + csv.Context.RegisterClassMap<TestNullMap>(); + var records = csv.GetRecords<Test>().ToList(); + + Assert.Equal(1, records[0].Id); + Assert.Null(records[0].Name); + Assert.Equal(2, records[1].Id); + Assert.Null(records[1].Name); + } + + [Fact] + public void IntConstantTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + using (var reader = new StringReader("1,one\r\n")) + using (var csv = new CsvReader(reader, config)) + { + csv.Context.RegisterClassMap<TestIntMap>(); + var records = csv.GetRecords<Test>().ToList(); + + Assert.Equal(-1, records[0].Id); + Assert.Equal("one", records[0].Name); + } + } + + private class Test + { + public int Id { get; set; } + public string Name { get; set; } + } + + private sealed class TestStringMap : ClassMap<Test> + { + public TestStringMap() + { + Map(m => m.Id); + Map(m => m.Name).Constant("constant"); + } + } + + private sealed class TestNullMap : ClassMap<Test> + { + public TestNullMap() + { + Map(m => m.Id); + Map(m => m.Name).Constant(null); + } + } + + private sealed class TestIntMap : ClassMap<Test> + { + public TestIntMap() + { + Map(m => m.Id).Constant(-1); + Map(m => m.Name); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs new file mode 100644 index 0000000..a96df82 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ConstructorParametersTests.cs @@ -0,0 +1,220 @@ +// 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.Globalization; +using System.IO; +using System.Linq; + +namespace CsvHelper.Tests.Reading +{ + + public class ConstructorParametersTests + { + [Fact] + public void ValueTypesParamsMatchPropsTest() + { + 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<ValueTypesParamsMatchProps>().ToList(); + + Assert.Single(records); + + var record = records[0]; + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + [Fact] + public void ValueTypesParamsDontMatchPropsTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header) + }; + 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("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<ValueTypesParamsDontMatchProps>().ToList(); + + Assert.Single(records); + + var record = records[0]; + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + [Fact] + public void MultipleConstructorsTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header) + }; + 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("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<MultipleConstructors>().ToList(); + + Assert.Single(records); + + var record = records[0]; + + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + [Fact] + public void UseDifferentConstructorTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header), + GetConstructor = args => args.ClassType.GetConstructors().First(), + }; + 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("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<MultipleConstructors>().ToList(); + + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Null(record.Name); + } + } + + [Fact] + public void UseDifferentConstructorWhenDefaultIsAvailableTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => CultureInfo.CurrentCulture.TextInfo.ToTitleCase(args.Header), + ShouldUseConstructorParameters = args => + !args.ParameterType.IsUserDefinedStruct() + && !args.ParameterType.IsInterface + && Type.GetTypeCode(args.ParameterType) == TypeCode.Object, + }; + 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("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<MultipleConstructorsWithDefault>().ToList(); + + Assert.Single(records); + + var record = records[0]; + Assert.Equal(1, record.Id); + Assert.Equal("one", record.Name); + } + } + + private class ValueTypesParamsMatchProps + { + public int Id { get; private set; } + + public string Name { get; private set; } + + public ValueTypesParamsMatchProps(int Id, string Name) + { + this.Id = Id; + this.Name = Name; + } + } + + private class ValueTypesParamsDontMatchProps + { + public int Id { get; private set; } + + public string Name { get; private set; } + + public ValueTypesParamsDontMatchProps(int id, string name) + { + Id = id; + Name = name; + } + } + + private class MultipleConstructors + { + public int Id { get; private set; } + + public string Name { get; private set; } + + public MultipleConstructors(int id) + { + Id = id; + } + + public MultipleConstructors(int id, string name) + { + Id = id; + Name = name; + } + + public MultipleConstructors(string name) + { + Name = name; + } + } + + private class MultipleConstructorsWithDefault + { + public int Id { get; private set; } + + public string Name { get; private set; } + + public MultipleConstructorsWithDefault() { } + + public MultipleConstructorsWithDefault(int id, string name) + { + Id = id; + Name = name; + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs new file mode 100644 index 0000000..7139409 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DetectColumnCountChangesTests.cs @@ -0,0 +1,199 @@ +// 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.Globalization; +using System.IO; +using System.Linq; +using CsvHelper.Configuration; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class DetectColumnCountChangesTests + { + [Fact] + public void ConsistentColumnsWithDetectColumnChangesTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + DetectColumnCountChanges = true, + }; + 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("Column 1,Column 2"); + writer.WriteLine("1,2"); + writer.Flush(); + stream.Position = 0; + + while (!csv.Read()) + { + } + } + } + + [Fact] + public void InconsistentColumnsMultipleRowsTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + DetectColumnCountChanges = true, + }; + 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("Column 1,Column 2"); + writer.WriteLine("1,2"); // Valid + writer.WriteLine("1,2,3"); // Error - too many fields + writer.WriteLine("1,2"); // Valid + writer.WriteLine("1"); // Error - not enough fields + writer.WriteLine("1,2,3,4"); // Error - too many fields + writer.WriteLine("1,2"); // Valid + writer.WriteLine("1,2"); // Valid + writer.Flush(); + stream.Position = 0; + + var failCount = 0; + + while (true) + { + try + { + if (!csv.Read()) + { + break; + } + } + catch (BadDataException) + { + failCount++; + } + } + + // Expect only 3 errors + Assert.Equal<int>(3, failCount); + } + } + + [Fact] + public void InconsistentColumnsSmallerTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + DetectColumnCountChanges = true, + }; + 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("1,2,3,4"); + writer.WriteLine("5,6,7"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + + try + { + csv.Read(); + throw new XUnitException(); + } + catch (BadDataException) + { + } + } + } + + [Fact] + public void InconsistentColumnsTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + DetectColumnCountChanges = true, + }; + 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("Column 1,Column 2"); + writer.WriteLine("1,2,3"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + + try + { + csv.Read(); + throw new XUnitException(); + } + catch (BadDataException) + { + } + } + } + + [Fact] + public void WillThrowOnMissingFieldStillWorksTest() + { + var missingFieldExceptionCount = 0; + var columnCountChangeExceptionCount = 0; + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + DetectColumnCountChanges = true, + HeaderValidated = null, + ReadingExceptionOccurred = (args) => + { + if (args.Exception is MissingFieldException) + { + missingFieldExceptionCount++; + } + else if (args.Exception is BadDataException) + { + columnCountChangeExceptionCount++; + } + + return false; + }, + }; + 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("1,2,3"); + writer.WriteLine("4,5"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<TestMap>(); + var records = csv.GetRecords<Test>().ToList(); + Assert.Equal(1, missingFieldExceptionCount); + Assert.Equal(1, columnCountChangeExceptionCount); + } + } + + private class Test + { + public int Id { get; set; } + public string Name { get; set; } + } + + private sealed class TestMap : ClassMap<Test> + { + public TestMap() + { + Map(m => m.Id); + Map(m => m.Name); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs new file mode 100644 index 0000000..d843eb0 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/DynamicTests.cs @@ -0,0 +1,126 @@ +// 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 CsvHelper.Tests.Mocks; +using Xunit; +using System.Collections.Generic; +using System.Globalization; +using System.IO; +using System.Linq; +using System.Text; + +namespace CsvHelper.Tests.Reading +{ + + public class DynamicTests + { + [Fact] + public void PrepareHeaderTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => args.Header.Replace(" ", string.Empty), + }; + 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("O ne,Tw o,Thr ee"); + writer.WriteLine("1,2,3"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<dynamic>().ToList(); + Assert.Equal("1", records[0].One); + Assert.Equal("2", records[0].Two); + Assert.Equal("3", records[0].Three); + } + } + + [Fact] + public void BlankHeadersTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + PrepareHeaderForMatch = args => + { + if (string.IsNullOrWhiteSpace(args.Header)) + { + return $"Blank{args.FieldIndex}"; + } + + return args.Header; + }, + }; + var s = new StringBuilder(); + s.AppendLine("Id,,"); + s.AppendLine("1,2"); + s.AppendLine("3"); + using (var reader = new StringReader(s.ToString())) + using (var csv = new CsvReader(reader, config)) + { + var records = csv.GetRecords<dynamic>().ToList(); + + var record = records[0]; + Assert.Equal("1", record.Id); + Assert.Equal("2", record.Blank1); + Assert.Equal(null, record.Blank2); + + record = records[1]; + Assert.Equal("3", record.Id); + Assert.Equal(null, record.Blank1); + Assert.Equal(null, record.Blank2); + } + } + + [Fact] + public void DuplicateFieldNamesTest() + { + var headerNameCounts = new Dictionary<string, int>(); + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + GetDynamicPropertyName = args => + { + var header = args.Context.Reader.HeaderRecord[args.FieldIndex]; + var prepareHeaderForMatchArgs = new PrepareHeaderForMatchArgs(header, args.FieldIndex); + header = args.Context.Reader.Configuration.PrepareHeaderForMatch(prepareHeaderForMatchArgs); + var name = headerNameCounts[header] > 1 ? $"{header}{args.FieldIndex}" : header; + + return name; + }, + }; + var parser = new ParserMock(config) + { + { "Id", "Name", "Name" }, + { "1", "foo", "bar" }, + null + }; + using (var csv = new CsvReader(parser)) + { + csv.Read(); + csv.ReadHeader(); + var counts = + (from header in csv.Context.Reader.HeaderRecord.Select((h, i) => csv.Configuration.PrepareHeaderForMatch(new PrepareHeaderForMatchArgs(h, i))) + group header by header into g + select new + { + Header = g.Key, + Count = g.Count() + }).ToDictionary(x => x.Header, x => x.Count); + foreach (var count in counts) + { + headerNameCounts.Add(count.Key, count.Value); + } + + var records = csv.GetRecords<dynamic>().ToList(); + var record = records[0]; + Assert.Equal("1", record.Id); + Assert.Equal("foo", record.Name1); + Assert.Equal("bar", record.Name2); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs new file mode 100644 index 0000000..0400092 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/EmptyTextReaderTests.cs @@ -0,0 +1,25 @@ +// 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.Globalization; +using System.IO; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class EmptyTextReaderTests + { + [Fact] + public void EmptyStreamDoesntFailTest() + { + using( var stream = new MemoryStream() ) + using( var reader = new StreamReader( stream ) ) + using( var csv = new CsvReader(reader, CultureInfo.InvariantCulture) ) + { + Assert.False( csv.Read() ); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs new file mode 100644 index 0000000..5aeed79 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleGetRecordsTests.cs @@ -0,0 +1,60 @@ +// 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.Globalization; +using System.IO; +using System.Linq; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class MultipleGetRecordsTests + { + [Fact] + public void GetRecordsAfterRefillingReaderTest() + { + 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.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<Test>().ToList(); + + var position = stream.Position; + writer.WriteLine("2,two"); + writer.Flush(); + stream.Position = position; + + records = csv.GetRecords<Test>().ToList(); + + Assert.Single(records); + Assert.Equal(2, records[0].Id); + Assert.Equal("two", records[0].Name); + + position = stream.Position; + writer.WriteLine("3,three"); + writer.Flush(); + stream.Position = position; + + records = csv.GetRecords<Test>().ToList(); + + Assert.Single(records); + Assert.Equal(3, records[0].Id); + Assert.Equal("three", records[0].Name); + } + } + + private class Test + { + public int Id { get; set; } + public string Name { get; set; } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs new file mode 100644 index 0000000..49a0b22 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/MultipleHeadersTests.cs @@ -0,0 +1,114 @@ +// 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.Globalization; +using System.IO; +using CsvHelper.Configuration; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class MultipleHeadersTests + { + [Fact] + public void ReadWithoutMapTest() + { + 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("A,B"); + writer.WriteLine("1,one"); + writer.WriteLine("Y,Z"); + writer.WriteLine("two,2"); + writer.Flush(); + stream.Position = 0; + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + + Assert.Equal(1, csv.GetField<int>("A")); + Assert.Equal("one", csv.GetField("B")); + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + + Assert.Equal("two", csv.GetField("Y")); + Assert.Equal(2, csv.GetField<int>("Z")); + } + } + + [Fact] + public void ReadWithMapTest() + { + 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("A,B"); + writer.WriteLine("1,one"); + writer.WriteLine("Y,Z"); + writer.WriteLine("two,2"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<AlphaMap>(); + csv.Context.RegisterClassMap<OmegaMap>(); + + csv.Read(); + csv.ReadHeader(); + + csv.Read(); + var alphaRecord = csv.GetRecord<Alpha>(); + + Assert.Equal(1, alphaRecord.A); + Assert.Equal("one", alphaRecord.B); + + csv.Read(); + csv.ReadHeader(); + + csv.Read(); + var omegaRecord = csv.GetRecord<Omega>(); + + Assert.Equal("two", omegaRecord.Y); + Assert.Equal(2, omegaRecord.Z); + } + } + + private class Alpha + { + public int A { get; set; } + public string B { get; set; } + } + + private class Omega + { + public string Y { get; set; } + public int Z { get; set; } + } + + private sealed class AlphaMap : ClassMap<Alpha> + { + public AlphaMap() + { + Map(m => m.A); + Map(m => m.B); + } + } + + private sealed class OmegaMap : ClassMap<Omega> + { + public OmegaMap() + { + Map(m => m.Y); + Map(m => m.Z); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs new file mode 100644 index 0000000..c5fcdd5 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/NullableValuesInEmptyColumnsInputTests.cs @@ -0,0 +1,224 @@ +// 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 CsvHelper.Tests.Mocks; +using Xunit; +using System.Globalization; + +namespace CsvHelper.Tests.Reading +{ + + public class NullableValuesInEmptyColumnsInputTests + { + [Fact] + public void SingleColumnCsvWithHeadersAndSingleNullDataRowTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IgnoreBlankLines = false, + MissingFieldFound = null, + }; + var parser = new ParserMock(config) + { + { "NullableInt32Field" }, + { new string[0] }, + }; + + using (var csv = new CsvReader(parser)) + { + csv.Context.TypeConverterOptionsCache.GetOptions<int?>().NullValues.Add(string.Empty); + + // Read header row, assert header row columns: + Assert.True(csv.Read()); + Assert.True(csv.ReadHeader()); + Assert.Single(csv.HeaderRecord); + Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]); + + // Read single data row, assert single null value: + Assert.True(csv.Read()); + + var nullableIntValueByIndex = csv.GetField<int?>(index: 0); + var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.False(nullableIntValueByIndex.HasValue); + Assert.False(nullableIntValueByName.HasValue); + + // Read to end of file: + Assert.False(csv.Read()); + } + } + + [Fact] + public void SingleColumnCsvWithHeadersAndPresentAndNullDataRowTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IgnoreBlankLines = false, + MissingFieldFound = null, + }; + var parser = new ParserMock(config) + { + { "NullableInt32Field" }, + { "1" }, + { new string[0] }, + { "3" }, + }; + + using (var csv = new CsvReader(parser)) + { + csv.Context.TypeConverterOptionsCache.GetOptions<int?>().NullValues.Add(string.Empty); + + // Read header row, assert header row columns: + Assert.True(csv.Read()); + Assert.True(csv.ReadHeader()); + Assert.Single(csv.HeaderRecord); + Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]); + + // Read first data row, assert "1" value: + Assert.True(csv.Read()); + + var nullableIntValueByIndex = csv.GetField<int?>(0); + var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.True(nullableIntValueByIndex.HasValue); + Assert.True(nullableIntValueByName.HasValue); + + Assert.Equal(1, nullableIntValueByIndex); + Assert.Equal(1, nullableIntValueByName); + + // Read second data row, assert null value: + Assert.True(csv.Read()); + + nullableIntValueByIndex = csv.GetField<int?>(0); + nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.False(nullableIntValueByIndex.HasValue); + Assert.False(nullableIntValueByName.HasValue); + + // Read third data row, assert "3" value: + Assert.True(csv.Read()); + + nullableIntValueByIndex = csv.GetField<int?>(0); + nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.True(nullableIntValueByIndex.HasValue); + Assert.True(nullableIntValueByName.HasValue); + + Assert.Equal(3, nullableIntValueByIndex); + Assert.Equal(3, nullableIntValueByName); + + // Read to end of file: + Assert.False(csv.Read()); + } + } + + [Fact] + public void TwoColumnCsvWithHeadersAndPresentAndNullDataRowTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IgnoreBlankLines = false, + MissingFieldFound = null, + }; + var parser = new ParserMock(config) + { + { "NullableInt32Field", "NullableStringField" }, + { "1" }, + { "", "Foo" }, + { "", "" }, + { "4", "Bar" }, + }; + + using (var csv = new CsvReader(parser)) + { + csv.Context.TypeConverterOptionsCache.GetOptions<string>().NullValues.Add(string.Empty); // Read empty fields as nulls instead of `""`. + + // Read header row, assert header row columns: + Assert.True(csv.Read()); + Assert.True(csv.ReadHeader()); + Assert.Equal(2, csv.HeaderRecord.Length); + Assert.Equal("NullableInt32Field", csv.HeaderRecord[0]); + Assert.Equal("NullableStringField", csv.HeaderRecord[1]); + + // Read first data row: + Assert.True(csv.Read()); + + // Read `Int32?`, assert "1" value: + var nullableIntValueByIndex = csv.GetField<int?>(0); + var nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.True(nullableIntValueByIndex.HasValue); + Assert.True(nullableIntValueByName.HasValue); + + Assert.Equal(1, nullableIntValueByIndex); + Assert.Equal(1, nullableIntValueByName); + + // Read nullable String, assert null value: + var strByIndex = csv.GetField<string>(1); + var strByName = csv.GetField<string>("NullableStringField"); + + Assert.Null(strByIndex); + Assert.Null(strByName); + + // Read second data row: + Assert.True(csv.Read()); + + // Read `Int32?`, assert NULL value: + nullableIntValueByIndex = csv.GetField<int?>(0); + nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.False(nullableIntValueByIndex.HasValue); + Assert.False(nullableIntValueByName.HasValue); + + // Read nullable String, assert "Foo" value: + strByIndex = csv.GetField<string>(1); + strByName = csv.GetField<string>("NullableStringField"); + + Assert.Equal("Foo", strByIndex); + Assert.Equal("Foo", strByName); + + // Read third data row: + Assert.True(csv.Read()); + + // Read `Int32?`, assert NULL value: + nullableIntValueByIndex = csv.GetField<int?>(0); + nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.False(nullableIntValueByIndex.HasValue); + Assert.False(nullableIntValueByName.HasValue); + + // Read nullable String, assert "Foo" value: + strByIndex = csv.GetField<string>(1); + strByName = csv.GetField<string>("NullableStringField"); + + Assert.Null(strByIndex); + Assert.Null(strByName); + + // Read fourth data row: + Assert.True(csv.Read()); + + // Read `Int32?`, assert "3" value: + nullableIntValueByIndex = csv.GetField<int?>(0); + nullableIntValueByName = csv.GetField<int?>("NullableInt32Field"); + + Assert.True(nullableIntValueByIndex.HasValue); + Assert.True(nullableIntValueByName.HasValue); + + Assert.Equal(4, nullableIntValueByIndex); + Assert.Equal(4, nullableIntValueByName); + + // Read nullable String, assert "Bar" value: + strByIndex = csv.GetField<string>(1); + strByName = csv.GetField<string>("NullableStringField"); + + Assert.Equal("Bar", strByIndex); + Assert.Equal("Bar", strByName); + + // Read to end of file: + Assert.False(csv.Read()); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs new file mode 100644 index 0000000..af192f0 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/PrivateSettersInParentTests.cs @@ -0,0 +1,90 @@ +// 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.Reading +{ + + public class PrivateSettersInParentTests + { + [Fact] + public void AutoMappingTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IncludePrivateMembers = true, + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvReader(reader, config)) + { + writer.WriteLine("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + var records = csv.GetRecords<Child>().ToList(); + Assert.Equal(1, records[0].Id); + Assert.Equal("one", records[0].Name); + } + } + + [Fact] + public void ClassMappingTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + IncludePrivateMembers = true, + }; + using (var stream = new MemoryStream()) + using (var reader = new StreamReader(stream)) + using (var writer = new StreamWriter(stream)) + using (var csv = new CsvReader(reader, config)) + { + writer.WriteLine("Id,Name"); + writer.WriteLine("1,one"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<ChildMap>(); + + var records = csv.GetRecords<Child>().ToList(); + Assert.Equal(1, records[0].Id); + Assert.Equal("one", records[0].Name); + } + } + + private class Parent + { + public int Id { get; private set; } + + public string Name { get; set; } + + public Parent() { } + + public Parent(int id, string name) + { + Id = id; + Name = name; + } + } + + private class Child : Parent { } + + private sealed class ChildMap : ClassMap<Child> + { + public ChildMap() + { + Map(m => m.Id); + Map(m => m.Name); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs new file mode 100644 index 0000000..a502db4 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ReadHeaderTests.cs @@ -0,0 +1,166 @@ +// 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 CsvHelper.Configuration; +using CsvHelper.Tests.Mocks; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class ReadHeaderTests + { + [Fact] + public void ReadHeaderReadsHeaderTest() + { + var parser = new ParserMock + { + { "Id", "Name" }, + { "1", "One" }, + { "2", "two" }, + null + }; + + var csv = new CsvReader(parser); + csv.Read(); + csv.ReadHeader(); + + Assert.NotNull(csv.HeaderRecord); + Assert.Equal("Id", csv.HeaderRecord[0]); + Assert.Equal("Name", csv.HeaderRecord[1]); + } + + [Fact] + public void ReadHeaderDoesNotAffectCurrentRecordTest() + { + var parser = new ParserMock + { + { "Id", "Name" }, + { "1", "One" }, + { "2", "two" }, + null, + }; + + var csv = new CsvReader(parser); + csv.Read(); + csv.ReadHeader(); + + Assert.Equal("Id", csv.Parser[0]); + Assert.Equal("Name", csv.Parser[1]); + } + + [Fact] + public void ReadingHeaderFailsWhenReaderIsDoneTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + var parser = new ParserMock(config) + { + { "Id", "Name" }, + { "1", "One" }, + { "2", "two" }, + null, + }; + + var csv = new CsvReader(parser); + while (csv.Read()) { } + + Assert.Throws<ReaderException>(() => csv.ReadHeader()); + } + + [Fact] + public void ReadingHeaderFailsWhenNoHeaderRecordTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + var parser = new ParserMock(config) + { + { "Id", "Name" }, + { "1", "One" }, + { "2", "two" }, + null + }; + + var csv = new CsvReader(parser); + + Assert.Throws<ReaderException>(() => csv.ReadHeader()); + } + + [Fact] + public void ReadingHeaderDoesNotFailWhenHeaderAlreadyReadTest() + { + var parser = new ParserMock + { + { "Id", "Name" }, + { "1", "One" }, + { "2", "two" }, + null + }; + + var csv = new CsvReader(parser); + csv.Read(); + csv.ReadHeader(); + csv.ReadHeader(); + } + + [Fact] + public void ReadHeaderResetsNamedIndexesTest() + { + var parser = new ParserMock + { + { "Id", "Name" }, + { "Name", "Id" }, + }; + var csv = new CsvReader(parser); + csv.Read(); + csv.ReadHeader(); + + Assert.Equal(0, csv.GetFieldIndex("Id")); + Assert.Equal(1, csv.GetFieldIndex("Name")); + + csv.Read(); + csv.ReadHeader(); + + Assert.Equal(1, csv.GetFieldIndex("Id")); + Assert.Equal(0, csv.GetFieldIndex("Name")); + } + + [Fact] + public void MultipleReadHeaderCallsWorksWithNamedIndexCacheTest() + { + var parser = new ParserMock + { + { "Id", "Name", "Id", "Name" }, + { "1", "one", "2", "two" }, + { "Name", "Id", "Name", "Id" }, + { "three", "3", "four", "4" }, + }; + var csv = new CsvReader(parser); + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + + Assert.Equal(1, csv.GetField<int>("Id")); + Assert.Equal("one", csv.GetField("Name")); + Assert.Equal(2, csv.GetField<int>("Id", 1)); + Assert.Equal("two", csv.GetField("Name", 1)); + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + + Assert.Equal(3, csv.GetField<int>("Id")); + Assert.Equal("three", csv.GetField("Name")); + Assert.Equal(4, csv.GetField<int>("Id", 1)); + Assert.Equal("four", csv.GetField("Name", 1)); + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs new file mode 100644 index 0000000..cac1fd8 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ShouldSkipRecordTests.cs @@ -0,0 +1,87 @@ +// 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.Linq; +using CsvHelper.Configuration; +using CsvHelper.Tests.Mocks; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class ShouldSkipRecordTests + { + [Fact] + public void SkipEmptyHeaderTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace), + }; + var parser = new ParserMock(config) + { + { " " }, + { "First,Second" }, + { "1", "2" }, + }; + + var csv = new CsvReader(parser); + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + Assert.Equal("1", csv.GetField(0)); + Assert.Equal("2", csv.GetField(1)); + } + + [Fact] + public void SkipEmptyRowTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace), + }; + var parser = new ParserMock(config) + { + { "First,Second" }, + { " " }, + { "1", "2" }, + }; + + var csv = new CsvReader(parser); + + csv.Read(); + csv.ReadHeader(); + csv.Read(); + Assert.Equal("1", csv.GetField(0)); + Assert.Equal("2", csv.GetField(1)); + } + + [Fact] + public void ShouldSkipWithEmptyRows() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + ShouldSkipRecord = args => args.Row[0].StartsWith("skipme") || args.Row.Parser.Record.All(string.IsNullOrWhiteSpace), + }; + + var parser = new ParserMock(config) + { + { "First,Second" }, + { "skipme," }, + { "" }, + { "1", "2" }, + }; + + var csv = new CsvReader(parser); + + csv.Read(); + csv.Read(); + Assert.Equal("1", csv.GetField(0)); + Assert.Equal("2", csv.GetField(1)); + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs new file mode 100644 index 0000000..2814fb2 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/TryGetTests.cs @@ -0,0 +1,228 @@ +// 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; +using System.Collections.Generic; +using System.Globalization; +using CsvHelper.Configuration; +using CsvHelper.Tests.Mocks; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class TryGetTests + { + [Fact] + public void TryGetFieldInvalidIndexTest() + { + var parserMock = new ParserMock + { + new[] { "One", "Two" }, + new[] { "one", "two" }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + + var got = reader.TryGetField(0, out int field); + Assert.False(got); + Assert.Equal(default(int), field); + } + + [Fact] + public void TryGetFieldInvalidNameTest() + { + var parserMock = new ParserMock + { + new[] { "One", "Two" }, + new[] { "one", "two" }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + + var got = reader.TryGetField("One", out int field); + Assert.False(got); + Assert.Equal(default(int), field); + } + + [Fact] + public void TryGetFieldTest() + { + var parserMock = new ParserMock + { + new[] { "One", "Two" }, + new[] { "1", "2" }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + reader.Read(); + + var got = reader.TryGetField(0, out int field); + Assert.True(got); + Assert.Equal(1, field); + } + + [Fact] + public void TryGetFieldStrictTest() + { + var parserMock = new ParserMock + { + new[] { "One", "Two" }, + new[] { "1", "2" }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + reader.Read(); + + var got = reader.TryGetField("One", out int field); + Assert.True(got); + Assert.Equal(1, field); + } + + [Fact] + public void TryGetFieldEmptyDate() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + + // DateTimeConverter.IsValid() doesn't work correctly + // so we need to test and make sure that the conversion + // fails for an empty string for a date. + var parserMock = new ParserMock(config) + { + new[] { " " }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + + var got = reader.TryGetField(0, out DateTime field); + + Assert.False(got); + Assert.Equal(DateTime.MinValue, field); + } + + [Fact] + public void TryGetNullableFieldEmptyDate() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + HasHeaderRecord = false, + }; + + // DateTimeConverter.IsValid() doesn't work correctly + // so we need to test and make sure that the conversion + // fails for an empty string for a date. + var parserMock = new ParserMock(config) + { + new[] { " " }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + + var got = reader.TryGetField(0, out DateTime? field); + + Assert.False(got); + Assert.Null(field); + } + + [Fact] + public void TryGetDoesNotThrowWhenWillThrowOnMissingFieldIsEnabled() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + MissingFieldFound = null, + }; + + var parserMock = new ParserMock(config) + { + new[] { "1" }, + null + }; + + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + Assert.False(reader.TryGetField("test", out string field)); + } + + [Fact] + public void TryGetFieldIndexTest() + { + var parserMock = new ParserMock + { + { "One", "Two", "Two" }, + { "1", "2", "3" } + }; + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + reader.Read(); + + var got = reader.TryGetField("Two", 0, out int field); + Assert.True(got); + Assert.Equal(2, field); + + got = reader.TryGetField("Two", 1, out field); + Assert.True(got); + Assert.Equal(3, field); + } + + [Fact] + public void TryGetMissingDateTimeFieldTest() + { + var parserMock = new ParserMock + { + { "Id", "Name" }, + { "1" }, + null + }; + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + reader.Read(); + + var got = reader.TryGetField(typeof(DateTime), "Name", out object field); + + Assert.False(got); + Assert.Equal(DateTime.MinValue, field); + } + + [Fact] + public void TryGetMissingDateTimeOffsetFieldTest() + { + var parserMock = new ParserMock + { + { "Id", "DateTime" }, + { "1" }, + null + }; + var reader = new CsvReader(parserMock); + reader.Read(); + reader.ReadHeader(); + reader.Read(); + + var got = reader.TryGetField(typeof(DateTimeOffset), "DateTime", out object field); + + Assert.False(got); + Assert.Equal(DateTimeOffset.MinValue, field); + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs new file mode 100644 index 0000000..1b9da38 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/ValidateTests.cs @@ -0,0 +1,197 @@ +// 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 System.Globalization; +using System.IO; +using System.Linq; +using System.Text; +using Xunit; + +namespace CsvHelper.Tests.Reading +{ + + public class ValidateTests + { + [Fact] + public void GenericValidateTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + MissingFieldFound = null, + }; + 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("Id,Name"); + writer.WriteLine(",one"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<GenericValidateMap>(); + Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList()); + } + } + + [Fact] + public void NonGenericValidateTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + MissingFieldFound = null, + }; + 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("Id,Name"); + writer.WriteLine(",one"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<NonGenericValidateMap>(); + Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList()); + } + } + + [Fact] + public void LogInsteadTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + MissingFieldFound = null, + }; + 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("Id,Name"); + writer.WriteLine("1,"); + writer.Flush(); + stream.Position = 0; + + var logger = new StringBuilder(); + csv.Context.RegisterClassMap(new LogInsteadMap(logger)); + csv.GetRecords<Test>().ToList(); + + var expected = new StringBuilder(); + expected.AppendLine("Field '' is not valid!"); + + Assert.Equal(expected.ToString(), logger.ToString()); + } + } + + [Fact] + public void CustomExceptionTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + MissingFieldFound = null, + }; + 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("Id,Name"); + writer.WriteLine(",one"); + writer.Flush(); + stream.Position = 0; + + csv.Context.RegisterClassMap<CustomExceptionMap>(); + Assert.Throws<CustomException>(() => csv.GetRecords<Test>().ToList()); + } + } + + [Fact] + public void ValidateMessageTest() + { + var config = new CsvConfiguration(CultureInfo.InvariantCulture) + { + }; + var s = new TestStringBuilder(config.NewLine); + s.AppendLine("Id,Name"); + s.AppendLine("1,one"); + using (var reader = new StringReader(s)) + using (var csv = new CsvReader(reader, config)) + { + csv.Context.RegisterClassMap<ValidationMessageMap>(); + var exception = Assert.Throws<FieldValidationException>(() => csv.GetRecords<Test>().ToList()); + Assert.StartsWith("Field 'one' was not foo.", exception.Message); + } + } + + private class Test + { + public int Id { get; set; } + + public string Name { get; set; } + } + + private sealed class GenericValidateMap : ClassMap<Test> + { + public GenericValidateMap() + { + Map(m => m.Id).Validate(args => !string.IsNullOrEmpty(args.Field)); + Map(m => m.Name); + } + } + + private sealed class NonGenericValidateMap : ClassMap<Test> + { + public NonGenericValidateMap() + { + AutoMap(System.Globalization.CultureInfo.InvariantCulture); + foreach (var memberMap in MemberMaps) + { + Map(typeof(Test), memberMap.Data.Member).Validate(args => !string.IsNullOrEmpty(args.Field)); + } + } + } + + private sealed class LogInsteadMap : ClassMap<Test> + { + public LogInsteadMap(StringBuilder logger) + { + Map(m => m.Id); + Map(m => m.Name).Validate(args => + { + var isValid = !string.IsNullOrEmpty(args.Field); + if (!isValid) + { + logger.AppendLine($"Field '{args.Field}' is not valid!"); + } + + return true; + }); + } + } + + private sealed class CustomExceptionMap : ClassMap<Test> + { + public CustomExceptionMap() + { + Map(m => m.Id).Validate(field => throw new CustomException()); + Map(m => m.Name); + } + } + + private class CustomException : CsvHelperException + { + } + + private class ValidationMessageMap : ClassMap<Test> + { + public ValidationMessageMap() + { + Map(m => m.Id); + Map(m => m.Name).Validate(args => args.Field == "foo", args => $"Field '{args.Field}' was not foo."); + } + } + } +} diff --git a/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs new file mode 100644 index 0000000..a39d899 --- /dev/null +++ b/ThirdParty/CsvHelper-master/tests/CsvHelper.Tests/Reading/YieldTests.cs @@ -0,0 +1,142 @@ +// 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; +using System.Text; +using System.Threading.Tasks; + +namespace CsvHelper.Tests.Reading +{ + + public class YieldTests + { + [Fact] + public void GetRecordsGeneric_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + IEnumerable<Foo> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.GetRecords<Foo>(); + } + Assert.Throws<ObjectDisposedException>(() => records.ToList()); + } + + [Fact] + public void GetRecords_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + IEnumerable<object> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.GetRecords(typeof(Foo)); + } + + Assert.Throws<ObjectDisposedException>(() => records.ToList()); + } + + [Fact] + public void EnumerateRecords_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + Foo record = null; + IEnumerable<Foo> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.EnumerateRecords(record); + } + + Assert.Throws<ObjectDisposedException>(() => records.ToList()); + } + +#if !NET45 + [Fact] + public async Task GetRecordsAsyncGeneric_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + IAsyncEnumerable<Foo> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.GetRecordsAsync<Foo>(); + } + + await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync()); + } + + [Fact] + public async Task GetRecordsAsync_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + IAsyncEnumerable<object> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.GetRecordsAsync(typeof(Foo)); + } + + await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync()); + } + + [Fact] + public async Task EnumerateRecordsAsync_Disposed_ThrowsObjectDisposedExceptionTest() + { + var parserMock = new ParserMock + { + new[] { "Id", "Name" }, + new[] { "1", "one" }, + null + }; + + Foo record = null; + IAsyncEnumerable<Foo> records; + using (var csv = new CsvReader(parserMock)) + { + records = csv.EnumerateRecordsAsync(record); + } + + await Assert.ThrowsAsync<ObjectDisposedException>(async () => await records.GetAsyncEnumerator().MoveNextAsync()); + } +#endif + + private class Foo + { + public int Id { get; set; } + + public string Name { get; set; } + } + } +} |