public static void CheckSampleData1(CsvRecordReader csv) { Assert.AreEqual(CsvReaderSampleData.SampleData1FieldCount, csv.FieldCount); if (csv.HasHeaders) { var headers = csv.GetFieldHeaders(); Assert.AreEqual(0, headers.GetFieldIndex(SampleData1Header0)); Assert.AreEqual(1, headers.GetFieldIndex(SampleData1Header1)); Assert.AreEqual(2, headers.GetFieldIndex(SampleData1Header2)); Assert.AreEqual(3, headers.GetFieldIndex(SampleData1Header3)); Assert.AreEqual(4, headers.GetFieldIndex(SampleData1Header4)); Assert.AreEqual(5, headers.GetFieldIndex(SampleData1Header5)); } Assert.AreEqual(-1, csv.CurrentRecordIndex); int recordCount = 0; foreach (CsvRecord record in csv) { CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, record.ToArray()); recordCount++; } if (csv.HasHeaders) { Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount, recordCount); } else { Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount + 1, recordCount); } }
public void FieldCountTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount, csv.FieldCount); } }
public void TestRecordSetFromBank() { var recordReader = new CsvRecordReader("USBank"); Stream s = TestUtils.RetrieveResource(testResource1); var oldRecords = recordReader.ReadFromStream(s, this.config); CCRecordSet recordSet = new CCRecordSet(oldRecords, config); int creditCount = oldRecords.Count(x => x.Amount < 0); Assert.AreEqual(creditCount, 1); try { recordSet.SerializeToFile(serializationOutput); Assert.IsTrue(File.Exists(serializationOutput)); CCRecordSet newRecordSet = CCRecordSet.FromFile(serializationOutput, config); CollectionAssert.AreEquivalent(recordSet.ToList(), newRecordSet.ToList()); } finally { if (File.Exists(serializationOutput)) { File.Delete(serializationOutput); } } }
public void GetValuesTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { object[] objValues = new object[CsvReaderSampleData.SampleData1RecordCount]; string[] values = new string[CsvReaderSampleData.SampleData1RecordCount]; foreach (IDataRecord reader in csv) { Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount, reader.GetValues(objValues)); for (int i = 0; i < reader.FieldCount; i++) { var csvRecord = (CsvRecord)reader; if (string.IsNullOrEmpty(csvRecord[i])) { Assert.AreEqual(DBNull.Value, objValues[i]); } values[i] = objValues[i].ToString(); } CsvReaderSampleData.CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, values); } } }
public void FieldCountTest1() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { CsvReaderSampleData.CheckSampleData1(csv); } }
public void TestDatasetCreate() { RedirectGlobalsToTempPath(); string filename = "test.dat"; CreateCsvTempFile(filename); CsvRecordExtractor extractor = new CsvRecordReader(new FileSource(filename)).Extractor("inputs", 1, 2, "targets", 3); CsvRecordExtractor clashingExtractor = new CsvRecordReader(new FileSource(filename)).Extractor("inputs", 1, 2); Assert.Throws <ArgumentNullException>(() => new ExtractedDataset(null, null)); Assert.Throws <ArgumentNullException>(() => new ExtractedDataset("name", null)); Assert.Throws <ArgumentNullException>(() => new ExtractedDataset("name", 10, null)); Assert.Throws <ArgumentNullException>(() => new ExtractedDataset("name", 10, null, extractor)); Assert.Throws <ArgumentException>(() => new ExtractedDataset("name", 10)); Assert.Throws <ArgumentException>(() => new ExtractedDataset("name", -3, extractor)); Assert.Throws <ArgumentException>(() => new ExtractedDataset("name")); Assert.Throws <ArgumentException>(() => new ExtractedDataset("name", extractor, clashingExtractor)); Assert.AreEqual("name", new ExtractedDataset("name", extractor).Name); Assert.Greater(new ExtractedDataset("name", extractor).TargetBlockSizeRecords, 0); Assert.Greater(new ExtractedDataset("name", ExtractedDataset.BlockSizeAuto, extractor).TargetBlockSizeRecords, 0); DeleteTempFile(filename); }
public void GetBytesTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Char[] temp = "abc".ToCharArray(); Byte[] value = new Byte[temp.Length]; for (int i = 0; i < temp.Length; i++) value[i] = Convert.ToByte(temp[i]); foreach (IDataRecord reader in csv) { Byte[] csvValue = new Byte[value.Length]; long count = reader.GetBytes(reader.GetOrdinal(typeof(String).FullName), 0, csvValue, 0, value.Length); Assert.AreEqual(value.Length, count); Assert.AreEqual(value.Length, csvValue.Length); for (int i = 0; i < value.Length; i++) Assert.AreEqual(value[i], csvValue[i]); } } }
public void GetBytesTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Char[] temp = "abc".ToCharArray(); Byte[] value = new Byte[temp.Length]; for (int i = 0; i < temp.Length; i++) { value[i] = Convert.ToByte(temp[i]); } foreach (IDataRecord reader in csv) { Byte[] csvValue = new Byte[value.Length]; long count = reader.GetBytes(reader.GetOrdinal(typeof(String).FullName), 0, csvValue, 0, value.Length); Assert.AreEqual(value.Length, count); Assert.AreEqual(value.Length, csvValue.Length); for (int i = 0; i < value.Length; i++) { Assert.AreEqual(value[i], csvValue[i]); } } } }
public void ArgumentTestIndexer3() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { string s = csv.Read()["asdf"]; } }
/// <summary> /// Create an extracted Connect4 dataset (6 by 7 field). /// The dataset is shuffled and one-hot-target-preprocessed. /// </summary> /// <param name="name">The optional name.</param> /// <returns>The Connect4 dataset.</returns> public static IDataset Connect4(string name = "connect4") { CsvRecordExtractor csvExtractor = new CsvRecordReader( new MultiSource(new FileSource("connect-4.data"), new UrlSource("https://raw.githubusercontent.com/moroshko/connect4/master/connect-4.data"))) .Extractor("inputs", new[] { 0, 41 }, "targets", 42) .AddValueMapping(42, "loss", "draw", "win"); Dictionary <object, object> mappings = new Dictionary <object, object>() { ["x"] = 1, ["b"] = 0, ["o"] = -1 }; for (int i = 0; i < 42; i++) { csvExtractor.AddValueMapping(i, mapping: mappings); } var extractor = csvExtractor .Preprocess(new OneHotPreprocessor("targets", 0, 2)) .Preprocess(new ShufflePreprocessor()); return(new ExtractedDataset(name, 67557, extractor)); }
/// <summary> /// Create an extracted heart disease dataset, automatically download any required resources. /// This dataset is normalised, one-hot-target-preprocessed and shuffled. /// </summary> /// <param name="name">The optional name.</param> /// <returns>The heart disease dataset.</returns> public static IDataset HeartDisease(string name = "heart_disease") { IRecordExtractor extractor = new CsvRecordReader(separator: ' ', source: new MultiSource(new FileSource("reprocessed.hungarian.data"), new UrlSource("https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/reprocessed.hungarian.data"))) .Extractor("inputs", new[] { 0, 12 }, "targets", 13) .AddValueMapping(3, new Dictionary <object, object> { ["-9"] = 132.133 }) // substitute averages for missing values .AddValueMapping(4, new Dictionary <object, object> { ["-9"] = 231.224 }) .AddValueMapping(7, new Dictionary <object, object> { ["-9"] = 138.656 }) .AddSpanValueMapping(8, 12, new Dictionary <object, object> { ["-9"] = 0 }) .AddSpanValueMapping(5, 6, new Dictionary <object, object> { ["-9"] = 0 }) .Preprocess(new OneHotPreprocessor("targets", 0, 4)) .Preprocess(new AdaptivePerIndexNormalisingPreprocessor(0.0, 1.0, "inputs")) .Preprocess(new ShufflePreprocessor()); return(new ExtractedDataset(name, extractor)); }
public void TestDatasetBlockwiseSliceCreate() { RedirectGlobalsToTempPath(); string filename = nameof(TestDatasetBlockwiseSliceCreate) + "test.dat"; CreateCsvTempFile(filename); CsvRecordExtractor extractor = new CsvRecordReader(new FileSource(filename)).Extractor("inputs", 1, 2, "targets", 3); ExtractedDataset dataset = new ExtractedDataset("name", ExtractedDataset.BlockSizeAuto, extractor); Assert.Throws <ArgumentNullException>(() => new DatasetBlockwiseSlice(null, 0, 0, 1)); Assert.Throws <ArgumentException>(() => new DatasetBlockwiseSlice(dataset, 0, 0, 0)); Assert.Throws <ArgumentException>(() => new DatasetBlockwiseSlice(dataset, -1, 0, 1)); Assert.Throws <ArgumentException>(() => new DatasetBlockwiseSlice(dataset, 0, -1, 1)); Assert.Throws <ArgumentException>(() => new DatasetBlockwiseSlice(dataset, 1, 0, 1)); Assert.Throws <ArgumentException>(() => new DatasetBlockwiseSlice(dataset, 0, 2, 2)); DatasetBlockwiseSlice slice = new DatasetBlockwiseSlice(dataset, 0, 1, 3); Assert.AreSame(dataset, slice.UnderlyingDataset); Assert.AreEqual(0, slice.SplitBeginIndex); Assert.AreEqual(1, slice.SplitEndIndex); Assert.AreEqual(2, slice.SplitSize); Assert.AreEqual(3, slice.SplitInterval); Assert.AreEqual(dataset.Name, slice.Name); Assert.AreEqual(dataset.TargetBlockSizeRecords, slice.TargetBlockSizeRecords); Assert.AreEqual(dataset.SectionNames, slice.SectionNames); DeleteTempFile(filename); }
public void ArgumentTestIndexer2() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { string s = csv.Read()[CsvReaderSampleData.SampleData1RecordCount]; } }
public static void CheckSampleData1(CsvRecordReader csv) { Assert.AreEqual(CsvReaderSampleData.SampleData1FieldCount, csv.FieldCount); if (csv.HasHeaders) { var headers = csv.GetFieldHeaders(); Assert.AreEqual(0, headers.GetFieldIndex(SampleData1Header0)); Assert.AreEqual(1, headers.GetFieldIndex(SampleData1Header1)); Assert.AreEqual(2, headers.GetFieldIndex(SampleData1Header2)); Assert.AreEqual(3, headers.GetFieldIndex(SampleData1Header3)); Assert.AreEqual(4, headers.GetFieldIndex(SampleData1Header4)); Assert.AreEqual(5, headers.GetFieldIndex(SampleData1Header5)); } Assert.AreEqual(-1, csv.CurrentRecordIndex); int recordCount = 0; foreach (CsvRecord record in csv) { CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, record.ToArray()); recordCount++; } if (csv.HasHeaders) Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount, recordCount); else Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount + 1, recordCount); }
public void DefaultCsvReaderCanParseSimpleSampleFile() { var sampleCsv = new List <string> { "Order Number,Year,Month,Day,Product Number,Product Name,Count,Extra Col1,Extra Col2,Empty Column", "1000,2018,1,1,P-10001,Arugola,\"5,250.50\",Lorem,Ipsum,", "1001,2017,12,12,P-10002,Iceberg lettuce,500.00,Lorem,Ipsum," }; List <IReadOnlyDictionary <string, string> > records; using (var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(string.Join(Environment.NewLine, sampleCsv)))) using (var reader = new CsvRecordReader(memoryStream)) { records = reader.GetRecords().ToList(); } Assert.That(records != null && records.Count == 2, $"Null or miscounted - [{records?.Count ?? -1}]"); var record0Fields = string.Join(',', records[0].Keys); Assert.That(record0Fields.Equals(sampleCsv[0], StringComparison.Ordinal), $"Record[0] field names do not match header - [{record0Fields}]"); var record1Fields = string.Join(',', records[1].Keys); Assert.That(record1Fields.Equals(sampleCsv[0], StringComparison.Ordinal), $"Record[1] field names do not match header - [{record1Fields}]"); // Validate all non-header records for (var i = 1; i < sampleCsv.Count; i++) { Assert.AreEqual(sampleCsv[i].Replace("\"", string.Empty), string.Join(',', records[i - 1].Values), $"Record [{i}] values mismatch"); } }
public void TestCsvRecordReaderRead() { string filename = ".unittestscsvrecorreader" + nameof(TestCsvRecordReaderRead); CreateCsvTempFile(filename); FileSource source = new FileSource(filename, Path.GetTempPath()); CsvRecordReader reader = new CsvRecordReader(source); Assert.Throws <InvalidOperationException>(() => reader.Read(3)); reader.Prepare(); string[][] lineparts = (string[][])reader.Read(2); Assert.AreEqual(2, lineparts.Length); Assert.AreEqual(5, lineparts[0].Length); Assert.AreEqual(new[] { "5.1", "3.5", "1.4", "0.2", "Iris-setosa" }, lineparts[0]); lineparts = (string[][])reader.Read(3); Assert.AreEqual(1, lineparts.Length); Assert.AreEqual(5, lineparts[0].Length); reader.Dispose(); DeleteTempFile(filename); }
public void ParsingTest2() { // ["Bob said, ""Hey!""",2, 3 ] const string data = "\"Bob said, \"\"Hey!\"\"\",2, 3 "; using (CsvRecordReader csv = new CsvRecordReader(new StringReader(data), false)) { CsvRecord record; record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(@"Bob said, ""Hey!""", record[0]); Assert.AreEqual("2", record[1]); Assert.AreEqual("3", record[2]); Assert.IsNull(csv.Read()); } using (CsvRecordReader csv = new CsvRecordReader(new StringReader(data), false, ',', '"', '"', '#', ValueTrimmingOptions.None)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(@"Bob said, ""Hey!""", record[0]); Assert.AreEqual("2", record[1]); Assert.AreEqual(" 3 ", record[2]); Assert.IsNull(csv.Read()); } }
public void ArgumentTestIndexer1() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { record = csv.Read(); string s = record[-1]; } }
public void ArgumentTestIndexer9() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { var record = csv.Read(); string s = record["asdf"]; } }
public void ParsingTest37() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { csv.SupportsMultiline = false; CsvReaderSampleData.CheckSampleData1(csv); } }
public void ParsingTest19() { string data = String.Empty; using (CsvRecordReader csv = new CsvRecordReader(new System.IO.StringReader(data), false)) { Assert.IsNull(csv.Read()); } }
static void Main(string[] args) { config = C3Configuration.LoadFromConfigurationManager(); var options = new Options(); if (CommandLine.Parser.Default.ParseArguments(args, options)) { if (options.Command == CommandType.IMPORT) { IRecordReader bankRecordReader = null; try { bankRecordReader = new CsvRecordReader(options.BankType); } catch (ApplicationException e) { Console.WriteLine($"Unable to create '{options.BankType}' record reader:\n{e.Message}"); Environment.Exit(-1); } if (!File.Exists(options.BaseFile)) { Console.WriteLine("Base file {0} does not exist.", options.BaseFile); } else if (!File.Exists(options.InputFile)) { Console.WriteLine("Input file {0} does not exist.", options.BaseFile); } else { try { Updater.ClassifyAndUpdate(options.BaseFile, options.InputFile, bankRecordReader, config); } catch (Exception e) { Console.WriteLine("Update failed: {0}", e.Message); } } } if (options.Command == CommandType.VIEW) { if (options.BaseFile == null) { Console.WriteLine("Base file must be specified."); return; } if (!File.Exists(options.BaseFile)) { Console.WriteLine($"Failed to open specified base file {options.BaseFile}"); return; } CCRecordSet records = CCRecordSet.FromFile(options.BaseFile, config); new Application().Run(new C3Window(records, options.BaseFile, config)); } } }
public void TestValidUSBankRecordFile() { var recordReader = new CsvRecordReader("USBank"); Stream s = TestUtils.RetrieveResource(testResource1); var records = recordReader.ReadFromStream(s, this.config); Assert.AreEqual(records[0].PredictedValues.Count(), 2); Assert.AreEqual(records[0].Amount, 8.88m); Assert.AreEqual(records[0].Description, "WHOLEFDS BKN, #10220 BROOKLYN NY"); // test commas }
public void GetFieldHeadersTest1() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false)) { var headers = csv.GetFieldHeaders(); Assert.IsNull(headers); Assert.IsFalse(csv.HasHeaders); } }
public void GetFieldHeadersTest_EmptyCsv() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("#asdf\n\n#asdf,asdf"), true)) { var headers = csv.GetFieldHeaders(); Assert.IsNotNull(headers); Assert.AreEqual(0, headers.Length); } }
public void ParsingTest42() { using (var csv = new CsvRecordReader(new StringReader(" "), false)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(1, csv.FieldCount); Assert.AreEqual(string.Empty, record[0]); Assert.IsNull(csv.Read()); } }
/// <summary> /// Create an extracted parkinsons dataset, automatically download any required resources. /// This dataset is normalised and shuffled. /// </summary> /// <param name="name"></param> /// <returns></returns> public static IDataset Parkinsons(string name = "parkinsons") { IRecordExtractor extractor = new CsvRecordReader(skipFirstLine: true, source: new MultiSource(new FileSource("parkinsons.data"), new UrlSource("https://archive.ics.uci.edu/ml/machine-learning-databases/parkinsons/parkinsons.data"))) .Extractor("inputs", new[] { 1, 16 }, new[] { 18, 23 }, "targets", 17) .Preprocess(new PerIndexNormalisingPreprocessor(0.0, 1.0, "inputs")) .Preprocess(new ShufflePreprocessor()); return(new ExtractedDataset(name, extractor)); }
public void TestValidChaseRecordFile() { var recordReader = new CsvRecordReader("Chase"); Stream s = TestUtils.RetrieveResource(chaseTestResource); List <CCRecord> records = recordReader.ReadFromStream(s, this.config); Assert.AreEqual(records[0].PredictedValues.Count(), 2); Assert.AreEqual(records.Count, 21); Assert.AreEqual(records.Sum(r => r.Amount), 631.83m); }
public void IsDBNullTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { foreach (IDataRecord reader in csv) { Assert.IsTrue(reader.IsDBNull(reader.GetOrdinal(typeof(DBNull).FullName))); } } }
public void TestCsvRecordReaderExtract() { CsvRecordReader reader = new CsvRecordReader(new FileSource(".")); Assert.Throws <ArgumentException>(() => reader.Extractor()); Assert.Throws <ArgumentException>(() => reader.Extractor("name", "name")); Assert.Throws <ArgumentException>(() => reader.Extractor(1)); Assert.AreEqual(new[] { 0, 1, 2, 3, 6 }, reader.Extractor("inputs", new[] { 0, 3 }, 6).NamedColumnIndexMapping["inputs"]); }
public void GetStringTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { String value = "abc"; foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetString(reader.GetOrdinal(typeof(String).FullName))); } } }
public void GetCharTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Char value = 'a'; foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetChar(reader.GetOrdinal(typeof(Char).FullName))); } } }
public void GetBooleanTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Boolean value = true; foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetBoolean(reader.GetOrdinal(typeof(Boolean).FullName))); } } }
public void GetOrdinalTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { foreach (IDataRecord reader in csv) { Assert.AreEqual(0, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header0)); Assert.AreEqual(1, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header1)); Assert.AreEqual(2, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header2)); Assert.AreEqual(3, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header3)); Assert.AreEqual(4, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header4)); Assert.AreEqual(5, reader.GetOrdinal(CsvReaderSampleData.SampleData1Header5)); } } }
public void ParsingTest4() { const string data = "\"\n\r\n\n\r\r\",,\t,\n"; using (CsvRecordReader csv = new CsvRecordReader(new StringReader(data), false)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(4, csv.FieldCount); Assert.AreEqual("\n\r\n\n\r\r", record[0]); Assert.AreEqual("", record[1]); Assert.AreEqual("", record[2]); Assert.AreEqual("", record[3]); Assert.IsNull(csv.Read()); } }
public void ParsingTest7() { using (CsvRecordReader csv = new CsvRecordReader(new System.IO.StringReader("\r\n1\r\n"), false)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(',', csv.Delimiter); Assert.AreEqual(0, csv.CurrentRecordIndex); Assert.AreEqual(1, csv.FieldCount); Assert.AreEqual("1", record[0]); Assert.IsNull(csv.Read()); } }
public void ParsingTest8() { const string data = "\"bob said, \"\"Hey!\"\"\",2, 3 "; using (CsvRecordReader csv = new CsvRecordReader(new System.IO.StringReader(data), false, ',', '\"', '\"', '#', ValueTrimmingOptions.UnquotedOnly)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("bob said, \"Hey!\"", record[0]); Assert.AreEqual("2", record[1]); Assert.AreEqual("3", record[2]); Assert.AreEqual(',', csv.Delimiter); Assert.AreEqual(0, csv.CurrentRecordIndex); Assert.AreEqual(3, csv.FieldCount); Assert.IsNull(csv.Read()); } }
public void ParsingTest35() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("\t"), false, '\t')) { Assert.AreEqual(2, csv.FieldCount); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual(string.Empty, record[0]); Assert.AreEqual(string.Empty, record[1]); Assert.IsNull(csv.Read()); } }
public void GetNameTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { foreach (IDataRecord reader in csv) { Assert.AreEqual(CsvReaderSampleData.SampleData1Header0, reader.GetName(0)); Assert.AreEqual(CsvReaderSampleData.SampleData1Header1, reader.GetName(1)); Assert.AreEqual(CsvReaderSampleData.SampleData1Header2, reader.GetName(2)); Assert.AreEqual(CsvReaderSampleData.SampleData1Header3, reader.GetName(3)); Assert.AreEqual(CsvReaderSampleData.SampleData1Header4, reader.GetName(4)); Assert.AreEqual(CsvReaderSampleData.SampleData1Header5, reader.GetName(5)); } } }
public void GetGuidTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Guid value = new Guid("{11111111-1111-1111-1111-111111111111}"); foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetGuid(reader.GetOrdinal(typeof(Guid).FullName))); } } }
public void GetFieldTypeTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { foreach (IDataRecord reader in csv) { for (int i = 0; i < reader.FieldCount; i++) Assert.AreEqual(typeof(string), reader.GetFieldType(i)); } } }
public void GetDecimalTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { Decimal value = 1; foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetDecimal(reader.GetOrdinal(typeof(Decimal).FullName))); } } }
public void GetDateTimeTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { DateTime value = new DateTime(2001, 1, 1); foreach (IDataRecord reader in csv) { Assert.AreEqual(value, reader.GetDateTime(reader.GetOrdinal(typeof(DateTime).FullName))); } } }
public void GetDataTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleTypedData1), true)) { foreach (IDataRecord reader in csv) { for (int i = 0; i < reader.FieldCount; i++) Assert.IsNull(reader.GetData(i)); } } }
public void ParsingTest39() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("00,01, \n10,11, "), false, CsvReader.DefaultDelimiter, CsvReader.DefaultQuote, CsvReader.DefaultEscape, CsvReader.DefaultComment, ValueTrimmingOptions.UnquotedOnly, 1)) { int fieldCount = csv.FieldCount; record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("00", record[0]); Assert.AreEqual("01", record[1]); Assert.AreEqual("", record[2]); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("10", record[0]); Assert.AreEqual("11", record[1]); Assert.AreEqual("", record[2]); Assert.IsNull(csv.Read()); } }
public void ParsingTest38() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("abc,def,ghi\n"), false)) { int fieldCount = csv.FieldCount; record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("abc", record[0]); Assert.AreEqual("def", record[1]); Assert.AreEqual("ghi", record[2]); Assert.IsNull(csv.Read()); } }
public void ParsingTest40() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("\"00\",\n\"10\","), false)) { Assert.AreEqual(2, csv.FieldCount); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("00", record[0]); Assert.AreEqual(string.Empty, record[1]); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("10", record[0]); Assert.AreEqual(string.Empty, record[1]); Assert.IsNull(csv.Read()); } }
public void GetValueTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { string[] values = new string[CsvReaderSampleData.SampleData1RecordCount]; foreach (IDataRecord reader in csv) { for (int i = 0; i < reader.FieldCount; i++) { object value = reader.GetValue(i); var csvRecord = (CsvRecord)reader; if (string.IsNullOrEmpty(csvRecord[i])) Assert.AreEqual(DBNull.Value, value); values[i] = value.ToString(); } CsvReaderSampleData.CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, values); } } }
public void IndexerByFieldIndexTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { string[] values = new string[CsvReaderSampleData.SampleData1RecordCount]; foreach (IDataRecord reader in csv) { for (int i = 0; i < reader.FieldCount; i++) values[i] = (string) reader[i]; CsvReaderSampleData.CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, values); } } }
public void ParsingTest34() { const string data = "\"Chicane\", \"Love on the Run\", \"Knight Rider\", \"This field contains a comma, but it doesn't matter as the field is quoted\"\r\n" + "\"Samuel Barber\", \"Adagio for Strings\", \"Classical\", \"This field contains a double quote character, \"\", but it doesn't matter as it is escaped\""; using (CsvRecordReader csv = new CsvRecordReader(new System.IO.StringReader(data), false, ',', '\"', '\"', '#', ValueTrimmingOptions.UnquotedOnly)) { record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("Chicane", record[0]); Assert.AreEqual("Love on the Run", record[1]); Assert.AreEqual("Knight Rider", record[2]); Assert.AreEqual("This field contains a comma, but it doesn't matter as the field is quoted", record[3]); Assert.AreEqual(0, csv.CurrentRecordIndex); Assert.AreEqual(4, csv.FieldCount); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("Samuel Barber", record[0]); Assert.AreEqual("Adagio for Strings", record[1]); Assert.AreEqual("Classical", record[2]); Assert.AreEqual("This field contains a double quote character, \", but it doesn't matter as it is escaped", record[3]); Assert.AreEqual(1, csv.CurrentRecordIndex); Assert.AreEqual(4, csv.FieldCount); Assert.IsNull(csv.Read()); } }
public void IndexerByFieldNameTest() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true)) { string[] values = new string[CsvReaderSampleData.SampleData1RecordCount]; foreach (IDataRecord reader in csv) { values[0] = (string) reader[CsvReaderSampleData.SampleData1Header0]; values[1] = (string) reader[CsvReaderSampleData.SampleData1Header1]; values[2] = (string) reader[CsvReaderSampleData.SampleData1Header2]; values[3] = (string) reader[CsvReaderSampleData.SampleData1Header3]; values[4] = (string) reader[CsvReaderSampleData.SampleData1Header4]; values[5] = (string) reader[CsvReaderSampleData.SampleData1Header5]; CsvReaderSampleData.CheckSampleData1(csv.HasHeaders, csv.CurrentRecordIndex, values); } } }
public void ParsingTest41() { using (CsvRecordReader csv = new CsvRecordReader(new StringReader("First record ,Second record"), false, CsvReader.DefaultDelimiter, CsvReader.DefaultQuote, CsvReader.DefaultEscape, CsvReader.DefaultComment, ValueTrimmingOptions.UnquotedOnly, 16)) { Assert.AreEqual(2, csv.FieldCount); record = csv.Read(); Assert.NotNull(record); Assert.AreEqual("First record", record[0]); Assert.AreEqual("Second record", record[1]); Assert.IsNull(csv.Read()); } }