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 FieldCountTest()
{
using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), true))
{
Assert.AreEqual(CsvReaderSampleData.SampleData1RecordCount, csv.FieldCount);
}
}
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 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 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 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 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 ParsingTest37()
{
using (CsvRecordReader csv = new CsvRecordReader(new StringReader(CsvReaderSampleData.SampleData1), false))
{
csv.SupportsMultiline = false;
CsvReaderSampleData.CheckSampleData1(csv);
}
}
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 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 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 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 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());
}
}
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());
}
}
