public void ChangeMemberMapTest() { var config = new CsvHelper.Configuration.Configuration(); var map = config.AutoMap <A>(); map.Map(m => m.B.C.P3).Index(3); }
public void AutoMapWithExistingMapTest() { var config = new CsvHelper.Configuration.Configuration(); var existingMap = new SimpleMap(); config.Maps.Add(existingMap); var data = new { Simple = new Simple { Id = 1, Name = "one" } }; var map = config.AutoMap(data.GetType()); Assert.IsNotNull(map); Assert.AreEqual(0, map.MemberMaps.Count); Assert.AreEqual(1, map.ReferenceMaps.Count); // 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.IsNotInstanceOfType(map.ReferenceMaps[0].Data.Mapping, typeof(SimpleMap)); }
public void CommentThatCrossesBuffersShouldNotAddToFieldTest() { var config = new CsvHelper.Configuration.Configuration { AllowComments = true, BufferSize = 10 }; using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var parser = new CsvParser(reader, config)) { parser.Configuration.Delimiter = ","; writer.Write("1,2\r\n"); writer.Write("#commented line\r\n"); writer.Write("3,4"); writer.Flush(); stream.Position = 0; parser.Read(); var line = parser.Read(); Assert.AreEqual("3", line[0]); Assert.AreEqual("4", line[1]); } }
public void ConvertWithIndexEndTest() { var config = new CsvHelper.Configuration.Configuration { HasHeaderRecord = false }; var rowMock = new Mock <IReaderRow>(); var currentRecord = new[] { "1", "one", "1", "2", "3" }; var context = new ReadingContext(new StringReader(string.Empty), config, false) { Record = currentRecord }; rowMock.Setup(m => m.Configuration).Returns(config); rowMock.Setup(m => m.Context).Returns(context); rowMock.Setup(m => m.GetField(It.IsAny <Type>(), It.IsAny <int>())).Returns <Type, int>((type, index) => Convert.ToInt32(currentRecord[index])); var data = new MemberMapData(typeof(Test).GetProperty("List")) { Index = 2, IndexEnd = 3 }; data.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture; var converter = new IEnumerableGenericConverter(); var enumerable = (IEnumerable <int?>)converter.ConvertFromString("1", rowMock.Object, data); var list = enumerable.ToList(); Assert.AreEqual(2, list.Count); Assert.AreEqual(1, list[0]); Assert.AreEqual(2, list[1]); }
public static Configuration GetConfiguration(string datatypeName) { var conf = new CsvHelper.Configuration.Configuration() { Delimiter = ",", HasHeaderRecord = false }; switch (datatypeName.ToLower()) { case "parametres": conf.Delimiter = "\t"; conf.RegisterClassMap <Parametres.ParametersMap>(); return(conf); case "data": conf.RegisterClassMap <Data.DataMap>(); return(conf); case "dataindicbruit": conf.RegisterClassMap <Dataindicbruit.DataindicbruitMap>(); return(conf); default: throw new Exception($"bad type name : the parsing of the type {datatypeName} is not implemented"); } }
public void MultipleCharDelimiterWithBufferEndingInMiddleOfDelimiterTest() { var config = new CsvHelper.Configuration.Configuration { Delimiter = "|~|", BufferSize = 3, }; using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) using (var parser = new CsvParser(reader, config)) { writer.WriteLine("1|~|2"); writer.Flush(); stream.Position = 0; var row = parser.Read(); Assert.IsNotNull(row); Assert.AreEqual(2, row.Length); Assert.AreEqual("1", row[0]); Assert.AreEqual("2", row[1]); row = parser.Read(); Assert.IsNull(row); } }
public void ConvertWithIndexEndTest() { var config = new CsvHelper.Configuration.Configuration { HasHeaderRecord = false }; var rowMock = new Mock <IReaderRow>(); var headers = new[] { "Id", "Name", "Prop1", "Prop2", "Prop3" }; var currentRecord = new[] { "1", "One", "1", "2", "3" }; var context = new ReadingContext(new StringReader(string.Empty), config, false) { HeaderRecord = headers, Record = currentRecord }; rowMock.Setup(m => m.Configuration).Returns(config); rowMock.Setup(m => m.Context).Returns(context); rowMock.Setup(m => m.GetField(It.IsAny <Type>(), It.IsAny <int>())).Returns <Type, int>((type, index) => Convert.ToInt32(currentRecord[index])); var data = new MemberMapData(typeof(Test).GetProperty("Dictionary")) { Index = 2, IndexEnd = 3 }; data.TypeConverterOptions.CultureInfo = CultureInfo.CurrentCulture; var converter = new IDictionaryGenericConverter(); var dictionary = (IDictionary)converter.ConvertFromString("1", rowMock.Object, data); Assert.AreEqual(2, dictionary.Count); Assert.AreEqual(1, dictionary["Prop1"]); Assert.AreEqual(2, dictionary["Prop2"]); }
public void CircularDependencyWithMultiplePropertiesTest() { var config = new CsvHelper.Configuration.Configuration(); var map = config.AutoMap <A>(); Assert.AreEqual(1, map.MemberMaps.Count); Assert.AreEqual(3, map.ReferenceMaps.Count); }
public void AddingMappingsWithGenericMethod2Test() { var config = new CsvHelper.Configuration.Configuration(); config.RegisterClassMap <TestClassMappings>(); Assert.AreEqual(2, config.Maps[typeof(TestClass)].MemberMaps.Count); }
public void AddingMappingsWithInstanceMethodTest() { var config = new CsvHelper.Configuration.Configuration(); config.RegisterClassMap(new TestClassMappings()); Assert.AreEqual(2, config.Maps[typeof(TestClass)].MemberMaps.Count); }
public CSVBridge(Configuration config, ClassMap map = null) { _map = map; _config = config; //override IgnoreReadingExceptions so we can do internal error management //_config.IgnoreReadingExceptions = true; }
public void RegisterClassMapNonGenericTest() { var config = new CsvHelper.Configuration.Configuration(); Assert.IsNull(config.Maps[typeof(TestClass)]); config.RegisterClassMap(typeof(TestClassMappings)); Assert.IsNotNull(config.Maps[typeof(TestClass)]); }
public void RegisterClassInstanceTest() { var config = new CsvHelper.Configuration.Configuration(); Assert.IsNull(config.Maps[typeof(TestClass)]); config.RegisterClassMap(new TestClassMappings()); Assert.IsNotNull(config.Maps[typeof(TestClass)]); }
public void AutoMapWithDefaultConstructor() { var config = new CsvHelper.Configuration.Configuration(); ClassMap map = config.AutoMap <SimpleReferenceHasNoDefaultConstructor>(); Assert.AreEqual("Id", map.MemberMaps[0].Data.Names[0]); Assert.AreEqual("Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]); Assert.AreEqual("name", map.ReferenceMaps[0].Data.Mapping.ParameterMaps[0].Data.Name); }
public void PropertyMapAccessTest() { var config = new CsvHelper.Configuration.Configuration(); config.RegisterClassMap <AMap>(); config.Maps.Find <A>().Map(m => m.AId).Ignore(); Assert.AreEqual(true, config.Maps[typeof(A)].MemberMaps[0].Data.Ignore); }
static CSVHelper() { configuration = new CsvHelper.Configuration.Configuration() { CultureInfo = CultureInfo.InvariantCulture, HasHeaderRecord = false }; configuration.TypeConverterCache.AddConverter <string[]>(new EnumerableConverter <string>()); }
public void MapMultipleTypesTest() { var config = new CsvHelper.Configuration.Configuration(); config.RegisterClassMap <AMap>(); config.RegisterClassMap <BMap>(); Assert.IsNotNull(config.Maps[typeof(A)]); Assert.IsNotNull(config.Maps[typeof(B)]); }
public APrivateMap() { var config = new CsvHelper.Configuration.Configuration { IncludePrivateMembers = true, MemberTypes = MemberTypes.Fields }; AutoMap(config); }
/// <summary> /// Initializes a new instance of the <see cref="CsvDataSource" /> class. /// </summary> /// <param name="name">The source name.</param> /// <param name="connection">The connection.</param> /// <param name="filePattern">The file pattern.</param> /// <param name="mode">The file mode.</param> /// <param name="config">The CSV configuration.</param> /// <param name="fileSystem">The file system.</param> /// <exception cref="System.ArgumentNullException">If any arguments are null.</exception> public CsvDataSource(string name, DataConnection connection, string filePattern, FolderMode mode, Csv.Configuration config, IFileSystemService fileSystem) { this.name = name ?? throw new ArgumentNullException("name"); this.connection = connection ?? throw new ArgumentNullException("connection"); this.filePattern = filePattern ?? throw new ArgumentNullException("filePattern"); this.config = config ?? throw new ArgumentNullException("config"); this.fileSystem = fileSystem ?? throw new ArgumentNullException("fileSystem"); this.mode = mode; }
public void AutoMapEnumerableTest() { var config = new CsvHelper.Configuration.Configuration(); try { config.AutoMap(typeof(List <string>)); Assert.Fail(); } catch (ConfigurationException) {} }
public CSVBridge(ClassMap map = null, bool hasHeader = true) { _map = map; _config = new Configuration() { HasHeaderRecord = hasHeader }; //override IgnoreReadingExceptions so we can do internal error management //_config.IgnoreReadingExceptions = true; }
private static CsvHelper.Configuration.Configuration GetConfiguration() { if (CsvConfiguration == null) { CsvConfiguration = new CsvHelper.Configuration.Configuration(System.Globalization.CultureInfo.InvariantCulture) { MemberTypes = CsvHelper.Configuration.MemberTypes.Fields, }; } return(CsvConfiguration); }
public void CircularDependencyTest() { var config = new CsvHelper.Configuration.Configuration(); var map = config.AutoMap <ACircular>(); Assert.IsNotNull(map); Assert.AreEqual(1, map.MemberMaps.Count); Assert.AreEqual(1, map.ReferenceMaps.Count); Assert.AreEqual(1, map.ReferenceMaps[0].Data.Mapping.MemberMaps.Count); Assert.AreEqual(0, map.ReferenceMaps[0].Data.Mapping.ReferenceMaps.Count); }
/// <summary> /// Creates a CSV data reader from the files. /// </summary> /// <param name="files">The files to load.</param> /// <param name="config">The CSV configuration.</param> /// <returns> /// An IDataReader instance. /// </returns> /// <exception cref="System.ArgumentNullException">If files is null.</exception> public IDataReader CreateDataReader(IEnumerable<IFileInfo> files, Csv.Configuration config) { if (files == null) { throw new ArgumentNullException("files"); } var sourceFiles = files.Zip(this.fileContents, (l, r) => new StringSourceFile(l.FullName, r)); return new MultipleCsvDataReader(sourceFiles, config); }
public void EnsureInternalsAreSetupWhenPasingWriterAndConfigTest() { using (var stream = new MemoryStream()) using (var writer = new StreamWriter(stream)) { var config = new CsvHelper.Configuration.Configuration(); using (var csv = new CsvWriter(writer, config)) { Assert.AreSame(config, csv.Configuration); } } }
public void EnsureInternalsAreSetupWhenPassingReaderAndConfigTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) { var config = new CsvHelper.Configuration.Configuration(); using (var parser = new CsvParser(reader, config)) { Assert.AreSame(config, parser.Configuration); } } }
/// <summary> /// Initializes a new instance of the <see cref="MultipleCsvDataReader" /> class. /// </summary> /// <param name="sourceFiles">The source files.</param> /// <param name="config">The configuration.</param> /// <exception cref="System.ArgumentNullException">If any arguments are null.</exception> public MultipleCsvDataReader(IEnumerable <ISourceFile> sourceFiles, Csv.Configuration config) { if (sourceFiles == null) { throw new ArgumentNullException("sourceFiles"); } this.sourceFiles = new Queue <ISourceFile>(sourceFiles); this.config = config ?? throw new ArgumentNullException("config"); this.NextResultImpl(); }
public void AutoMapWithNestedHeaders() { var config = new CsvHelper.Configuration.Configuration { PrefixReferenceHeaders = true, }; var map = config.AutoMap <Nested>(); Assert.AreEqual("Simple1.Id", map.ReferenceMaps[0].Data.Mapping.MemberMaps[0].Data.Names[0]); Assert.AreEqual("Simple1.Name", map.ReferenceMaps[0].Data.Mapping.MemberMaps[1].Data.Names[0]); Assert.AreEqual("Simple2.Id", map.ReferenceMaps[1].Data.Mapping.MemberMaps[0].Data.Names[0]); Assert.AreEqual("Simple2.Name", map.ReferenceMaps[1].Data.Mapping.MemberMaps[1].Data.Names[0]); }
/// <summary> /// Initializes a new instance of the <see cref="CsvDataReader" /> class. /// </summary> /// <param name="source">The source.</param> /// <param name="sourceFile">The source file name to be embedded in the data stream.</param> /// <param name="config">The CSV configuration.</param> /// <exception cref="System.ArgumentNullException">If any arguments are null.</exception> public CsvDataReader(TextReader source, string sourceFile, Csv.Configuration config) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (sourceFile == null) { throw new ArgumentNullException(nameof(sourceFile)); } DittoEventSource.Log.LoadingFile(sourceFile); this.sourceFile = sourceFile; this.configuration = config ?? throw new ArgumentNullException(nameof(config)); this.reader = new CsvReader(source, config); var lastWriteTime = File.GetLastWriteTimeUtc(this.sourceFile); // NB: I have made a choice here to prefix internal columns with underscores because // I have no idea what the real column names could be. The _prefix is consistent with // the old C++ compiler implementation style. this.fixedFields.Add(Tuple.Create <string, Func <object> >("_LineNumber", () => this.currentRow + 1)); this.fixedFields.Add(Tuple.Create <string, Func <object> >("_SourceFile", () => this.sourceFile)); this.fixedFields.Add(Tuple.Create <string, Func <object> >("_LastWriteTimeUtc", () => lastWriteTime)); // Many reader functions throw exceptions until the first record has been read. this.closed = !this.reader.Read(); if (this.configuration.HasHeaderRecord) { this.reader.ReadHeader(); this.normalizedHeaders = this.reader.Context.HeaderRecord .Select(h => this.NormalizeFieldHeader(h)) .ToArray(); this.closed = !this.reader.Read(); } else { this.normalizedHeaders = Enumerable.Range(1, this.reader.Context.Record.Length) .Select(x => "Column" + x.ToString("G", CultureInfo.CurrentCulture)) .ToArray(); } }
public void EnsureReaderAndParserConfigIsAreSameTest() { using (var stream = new MemoryStream()) using (var reader = new StreamReader(stream)) { var csvReader = new CsvReader(reader); Assert.AreSame(csvReader.Configuration, csvReader.Parser.Configuration); var config = new CsvHelper.Configuration.Configuration(); var parser = new CsvParser(reader, config); csvReader = new CsvReader(parser); Assert.AreSame(csvReader.Configuration, csvReader.Parser.Configuration); } }