public void TestRead_WithSeparatedRecordFilter_SkipsRecordsMatchingCriteria()
{
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
SeparatedValueOptions options = new SeparatedValueOptions()
{
PartitionedRecordFilter = (record) => record.Length < 3
};
const string text = @"123,Bob Smith,4/21/2017
This is not a real record
234,Jay Smith,5/21/2017";
StringReader stringReader = new StringReader(text);
IReader parser = new SeparatedValueReader(stringReader, schema, options);
Assert.True(parser.Read(), "Could not read the first record.");
object[] actual1 = parser.GetValues();
Assert.Equal(new object[] { 123, "Bob Smith", new DateTime(2017, 04, 21) }, actual1);
Assert.True(parser.Read(), "Could not read the second record.");
object[] actual2 = parser.GetValues();
Assert.Equal(new object[] { 234, "Jay Smith", new DateTime(2017, 05, 21) }, actual2);
Assert.False(parser.Read(), "There should not be any more records.");
}
public void TestRead_WithSeparatedRecordFilter_SkipsRecordsMatchingCriteria()
{
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
const string text = @"123,Bob Smith,4/21/2017
This is not a real record
234,Jay Smith,5/21/2017";
StringReader stringReader = new StringReader(text);
var parser = new SeparatedValueReader(stringReader, schema);
parser.RecordRead += (sender, e) =>
{
e.IsSkipped = e.Values.Length < 3;
};
Assert.IsTrue(parser.Read(), "Could not read the first record.");
object[] actual1 = parser.GetValues();
CollectionAssert.AreEqual(new object[] { 123, "Bob Smith", new DateTime(2017, 04, 21) }, actual1);
Assert.IsTrue(parser.Read(), "Could not read the second record.");
object[] actual2 = parser.GetValues();
CollectionAssert.AreEqual(new object[] { 234, "Jay Smith", new DateTime(2017, 05, 21) }, actual2);
Assert.IsFalse(parser.Read(), "There should not be any more records.");
}
public void TestReader_ReadThreeTypes()
{
StringWriter stringWriter = new StringWriter();
var injector = getSchemaInjector();
var writer = new SeparatedValueWriter(stringWriter, injector);
writer.Write(new object[] { "First Batch", 2 });
writer.Write(new object[] { 1, "Bob Smith", new DateTime(2018, 06, 04), 12.34m });
writer.Write(new object[] { 2, "Jane Doe", new DateTime(2018, 06, 05), 34.56m });
writer.Write(new object[] { 46.9m, 23.45m, true });
string output = stringWriter.ToString();
Assert.AreEqual(@"First Batch,2
1,Bob Smith,20180604,12.34
2,Jane Doe,20180605,34.56
46.9,23.45,True
", output);
var stringReader = new StringReader(output);
var selector = getSchemaSelector();
var reader = new SeparatedValueReader(stringReader, selector);
Assert.IsTrue(reader.Read(), "The header record could not be read.");
var headerValues = reader.GetValues();
Assert.AreEqual(2, headerValues.Length);
Assert.AreEqual("First Batch", headerValues[0]);
Assert.AreEqual(2, headerValues[1]);
Assert.IsTrue(reader.Read(), "The first data record could not be read.");
var dataValues1 = reader.GetValues();
Assert.AreEqual(4, dataValues1.Length);
Assert.AreEqual(1, dataValues1[0]);
Assert.AreEqual("Bob Smith", dataValues1[1]);
Assert.AreEqual(new DateTime(2018, 6, 4), dataValues1[2]);
Assert.AreEqual(12.34m, dataValues1[3]);
Assert.IsTrue(reader.Read(), "The second data record could not be read.");
var dataValues2 = reader.GetValues();
Assert.AreEqual(4, dataValues2.Length);
Assert.AreEqual(2, dataValues2[0]);
Assert.AreEqual("Jane Doe", dataValues2[1]);
Assert.AreEqual(new DateTime(2018, 6, 5), dataValues2[2]);
Assert.AreEqual(34.56m, dataValues2[3]);
Assert.IsTrue(reader.Read(), "The footer record could not be read.");
var footerValues = reader.GetValues();
Assert.AreEqual(3, footerValues.Length);
Assert.AreEqual(46.9m, footerValues[0]);
Assert.AreEqual(23.45m, footerValues[1]);
Assert.AreEqual(true, footerValues[2]);
Assert.IsFalse(reader.Read());
}
public bool Read()
{
if (!reader.Read())
{
return(false);
}
object[] values = reader.GetValues();
Current = selector.Reader(values);
return(true);
}
public void TestRead_MultipleCallsToValues_ReturnsSameValues()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
string[] expected = new string[] { "a", "b", "c" };
object[] actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The same values were not returned multiple times.");
}
public void TestRead_MultipleCallsToValues_ReturnsSameValues()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
object[] expected = new object[] { "a", "b", "c" };
object[] actual = parser.GetValues();
Assert.Equal(expected, actual);
actual = parser.GetValues();
Assert.Equal(expected, actual);
}
public void TestGetValues_BlankLeadingSection_ReturnsNull()
{
using (MemoryStream stream = new MemoryStream())
{
SeparatedValueOptions options = new SeparatedValueOptions()
{
IsFirstRecordSchema = true
};
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new StringColumn("leading"))
.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created")
{
InputFormat = "M/d/yyyy", OutputFormat = "M/d/yyyy"
});
object[] sources = new object[] { "", 123, "Bob", new DateTime(2013, 1, 19) };
StringWriter stringWriter = new StringWriter();
SeparatedValueWriter builder = new SeparatedValueWriter(stringWriter, schema, options);
builder.Write(sources);
StringReader stringReader = new StringReader(stringWriter.ToString());
SeparatedValueReader parser = new SeparatedValueReader(stringReader, schema, options);
Assert.True(parser.Read(), "No records were found.");
object[] values = parser.GetValues();
Assert.Equal(schema.ColumnDefinitions.Count, values.Length);
Assert.Equal(null, values[0]);
Assert.Equal(sources[1], values[1]);
Assert.Equal(sources[2], values[2]);
Assert.Equal(sources[3], values[3]);
Assert.False(parser.Read(), "Too many records were found.");
}
}
public void TestRead_GetValuesWithoutReading_Throws()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
parser.GetValues();
}
public void TestRead_RecordWithCP1251Characters_ReturnsCorrectCharacters()
{
//---- Arrange -----------------------------------------------------
// Need to convert the string to target encoding because otherwise a string declared in VS will always be encoded as UTF-8
var text = Encoding.Convert(Encoding.UTF8, Encoding.GetEncoding(1251), Encoding.UTF8.GetBytes(@"123;Лучиано;1/17/2014"));
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id")).AddColumn(new StringColumn("name")).AddColumn(new DateTimeColumn("created"));
var options = new SeparatedValueOptions
{
IsFirstRecordSchema = false,
Separator = ";",
Encoding = Encoding.GetEncoding(1251)
};
var testee = new SeparatedValueReader(new MemoryStream(text), schema, options);
//---- Act ---------------------------------------------------------
var result = testee.Read();
//---- Assert ------------------------------------------------------
Assert.IsTrue(result, "Could not read the record.");
object[] expected = { 123, "Лучиано", new DateTime(2014, 1, 17) };
object[] actual = testee.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
}
public void TestGetValues_BlankLeadingSection_ReturnsNull()
{
using (MemoryStream stream = new MemoryStream())
{
SeparatedValueOptions options = new SeparatedValueOptions()
{
IsFirstRecordSchema = true
};
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new StringColumn("leading"))
.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created")
{
InputFormat = "M/d/yyyy", OutputFormat = "M/d/yyyy"
});
object[] sources = new object[] { "", 123, "Bob", new DateTime(2013, 1, 19) };
using (SeparatedValueWriter builder = new SeparatedValueWriter(stream, schema, options))
{
builder.Write(sources);
}
stream.Position = 0;
SeparatedValueReader parser = new SeparatedValueReader(stream, schema, options);
Assert.IsTrue(parser.Read(), "No records were found.");
object[] values = parser.GetValues();
Assert.AreEqual(schema.ColumnDefinitions.Count, values.Length, "The wrong number of values were read.");
Assert.AreEqual(null, values[0], "The first column was not interpreted as null.");
Assert.AreEqual(sources[1], values[1], "The second column was not parsed correctly.");
Assert.AreEqual(sources[2], values[2], "The third column was not parsed correctly.");
Assert.AreEqual(sources[3], values[3], "The forth column was not parsed correctly.");
Assert.IsFalse(parser.Read(), "Too many records were found.");
}
}
public void TestRead_ZeroLengthColumn()
{
//---- Arrange -----------------------------------------------------
var text = "104\t20\t1000\t00\tLausanne\tLausanne\tVD\t2\t\t0\t130\t5586\t19880301";
var options = new SeparatedValueOptions {
IsFirstRecordSchema = false, Separator = "\t"
};
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("OnrpId"))
.AddColumn(new Int32Column("Type"))
.AddColumn(new Int32Column("ZipCode"))
.AddColumn(new StringColumn("ZipCodeAddOn"))
.AddColumn(new StringColumn("TownShortName"))
.AddColumn(new StringColumn("TownOfficialName"))
.AddColumn(new StringColumn("CantonAbbreviation"))
.AddColumn(new Int16Column("MainLanguageCode"))
.AddColumn(new Int16Column("OtherLanguageCode"))
.AddColumn(new ByteColumn("HasSortfileData"))
.AddColumn(new Int32Column("LetterServiceOnrpId"))
.AddColumn(new Int32Column("MunicipalityId"))
.AddColumn(new StringColumn("ValidFrom"));
var testee = new SeparatedValueReader(new MemoryStream(Encoding.GetEncoding(1252).GetBytes(text)), options);
//---- Act ---------------------------------------------------------
var result = testee.Read();
//---- Assert ------------------------------------------------------
Assert.IsTrue(result);
Assert.AreEqual(schema.ColumnDefinitions.Count, testee.GetValues().Count());
}
public IEnumerable <T> GetData(string filePath, string separator = ";")
{
using (StreamReader streamReader = new StreamReader(filePath))
{
SeparatedValueOptions options = new SeparatedValueOptions {
IsFirstRecordSchema = true, Separator = separator, Quote = '\''
};
var separatedValueSchema = new SeparatedValueSchema();
var properties = Type.GetProperties();
foreach (var property in properties)
{
var propertyName = property.Name;
var columnDefinition = GetColumnDefinition(property.PropertyType, propertyName);
separatedValueSchema.AddColumn(columnDefinition);
}
SeparatedValueReader separatedValueReader = new SeparatedValueReader(streamReader, separatedValueSchema, options);
List <T> values = new List <T>();
while (separatedValueReader.Read())
{
var rowValues = separatedValueReader.GetValues();
var tRow = new T();
var propertiesObjectValues = properties.Zip(rowValues, (a, b) => new { PropType = a, PropValue = b });
foreach (var propertiesObjectValue in propertiesObjectValues)
{
Type.GetProperty(propertiesObjectValue.PropType.Name).SetValue(tRow, propertiesObjectValue.PropValue);
}
values.Add(tRow);
}
return(values);
}
}
public void TestRead_GetValuesWithoutReading_Throws()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
Assert.Throws <InvalidOperationException>(() => parser.GetValues());
}
private static object[] parseValues(string content)
{
StringReader stringReader = new StringReader(content);
var schema = getSchema();
SeparatedValueReader reader = new SeparatedValueReader(stringReader, schema);
Assert.True(reader.Read(), "The record could not be read.");
object[] values = reader.GetValues();
Assert.False(reader.Read(), "Too many records were read.");
return values;
}
public void RunFlatFiles_NoSchema()
{
var reader = new StringReader(data);
var csvReader = new SeparatedValueReader(reader);
var people = new List <object[]>();
while (csvReader.Read())
{
people.Add(csvReader.GetValues());
}
}
private static object[] parseValues(string content)
{
StringReader stringReader = new StringReader(content);
var schema = getSchema();
SeparatedValueReader reader = new SeparatedValueReader(stringReader, schema);
Assert.True(reader.Read(), "The record could not be read.");
object[] values = reader.GetValues();
Assert.False(reader.Read(), "Too many records were read.");
return(values);
}
private void assertRecords(object[][] expected, SeparatedValueReader reader)
{
for (int recordIndex = 0; recordIndex != expected.Length; ++recordIndex)
{
Assert.True(reader.Read(), String.Format("The record could not be read (Record {0}).", recordIndex));
object[] actualValues = reader.GetValues();
object[] expectedValues = expected[recordIndex];
assertRecord(expectedValues, actualValues, recordIndex);
}
Assert.False(reader.Read(), "There were more records read than expected.");
}
private static void assertValues(SeparatedValueReader reader, string firstName, string lastName, string street, string city, string state, string zip)
{
object[] values = reader.GetValues();
Assert.Equal(6, values.Length);
Assert.Equal(firstName, values[0]);
Assert.Equal(lastName, values[1]);
Assert.Equal(street, values[2]);
Assert.Equal(city, values[3]);
Assert.Equal(state, values[4]);
Assert.Equal(zip, values[5]);
}
public void TestRead_ValuesAfterEndOfFile_Throws()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
canRead = parser.Read();
Assert.IsFalse(canRead, "We should have reached the end of the file.");
parser.GetValues();
}
public void TestRead_ValuesAfterEndOfFile_Throws()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
canRead = parser.Read();
Assert.False(canRead, "We should have reached the end of the file.");
Assert.Throws <InvalidOperationException>(() => parser.GetValues());
}
private static object[] parseValues(string content)
{
byte[] encoded = Encoding.Default.GetBytes(content);
var schema = getSchema();
using (MemoryStream stream = new MemoryStream(encoded))
using (SeparatedValueReader reader = new SeparatedValueReader(stream, schema))
{
Assert.IsTrue(reader.Read(), "The record could not be read.");
object[] values = reader.GetValues();
Assert.IsFalse(reader.Read(), "Too many records were read.");
return values;
}
}
public void TestReadWrite_Comments()
{
StringWriter output = new StringWriter();
SeparatedValueWriter writer = new SeparatedValueWriter(output);
writer.Write(new[] { "a", "b", "c" });
writer.WriteRaw("# Hello, world!!!", true);
writer.Write(new[] { "d", "e", "f" });
StringReader input = new StringReader(output.ToString());
SeparatedValueReader reader = new SeparatedValueReader(input);
reader.RecordRead += (sender, e) =>
{
e.IsSkipped = e.Values.Length > 0 && e.Values[0].StartsWith("#");
};
Assert.IsTrue(reader.Read());
CollectionAssert.AreEqual(new[] { "a", "b", "c" }, reader.GetValues());
Assert.IsTrue(reader.Read());
CollectionAssert.AreEqual(new[] { "d", "e", "f" }, reader.GetValues());
Assert.IsFalse(reader.Read());
}
public void TestRead_SingleRecord_ReturnsTrueOnce()
{
const string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
string[] expected = new string[] { "a", "b", "c" };
object[] actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
canRead = parser.Read();
Assert.IsFalse(canRead, "No more records should have been read.");
}
public void TestRead_SingleRecord_ReturnsTrueOnce()
{
const string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
object[] expected = new object[] { "a", "b", "c" };
object[] actual = parser.GetValues();
Assert.Equal(expected, actual);
canRead = parser.Read();
Assert.False(canRead, "No more records should have been read.");
}
public void TestGetSchema_FirstRecordSchema_TooManyColumns_IgnoresTrailing()
{
const string text = @"id,name,created
123,Bob,1/19/2013,Hello";
StringReader stringReader = new StringReader(text);
SeparatedValueOptions options = new SeparatedValueOptions()
{
IsFirstRecordSchema = true
};
SeparatedValueReader parser = new SeparatedValueReader(stringReader, options);
Assert.IsTrue(parser.Read(), "The record could not be read.");
Assert.AreEqual(parser.GetSchema().ColumnDefinitions.Count, parser.GetValues().Length);
}
private static object[] parseValues(string content)
{
byte[] encoded = Encoding.Default.GetBytes(content);
var schema = getSchema();
using (MemoryStream stream = new MemoryStream(encoded))
using (SeparatedValueReader reader = new SeparatedValueReader(stream, schema))
{
Assert.IsTrue(reader.Read(), "The record could not be read.");
object[] values = reader.GetValues();
Assert.IsFalse(reader.Read(), "Too many records were read.");
return(values);
}
}
public void TestGetSchema_SchemaProvided_ParsesValues()
{
const string text = @"123,Bob,1/19/2013";
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)), schema);
Assert.IsTrue(parser.Read(), "The first record was skipped.");
object[] actual = parser.GetValues();
object[] expected = new object[] { 123, "Bob", new DateTime(2013, 1, 19) };
CollectionAssert.AreEqual(expected, actual, "The values were not parsed as expected.");
}
public void ShouldRoundTrip()
{
const string message = @"Tom,Hanselman,2016-06-0426 Walking Ice,Ace
";
StringReader stringReader = new StringReader(message);
SeparatedValueSchema outerSchema = new SeparatedValueSchema();
outerSchema.AddColumn(new StringColumn("FirstName"));
outerSchema.AddColumn(new StringColumn("LastName"));
FixedLengthSchema innerSchema = new FixedLengthSchema();
innerSchema.AddColumn(new DateTimeColumn("StartDate")
{
InputFormat = "yyyy-MM-dd", OutputFormat = "yyyy-MM-dd"
}, 10);
innerSchema.AddColumn(new Int32Column("Age"), 2);
innerSchema.AddColumn(new StringColumn("StageName"), new Window(20)
{
Alignment = FixedAlignment.RightAligned
});
outerSchema.AddColumn(new FixedLengthComplexColumn("PlayerStats", innerSchema));
outerSchema.AddColumn(new StringColumn("Nickname"));
SeparatedValueReader reader = new SeparatedValueReader(stringReader, outerSchema);
Assert.True(reader.Read(), "A record should have been read.");
object[] values = reader.GetValues();
Assert.Equal("Tom", values[0]);
Assert.Equal("Hanselman", values[1]);
Assert.IsType <object[]>(values[2]);
object[] playerValues = (object[])values[2];
Assert.Equal(new DateTime(2016, 06, 04), playerValues[0]);
Assert.Equal(26, playerValues[1]);
Assert.Equal("Walking Ice", playerValues[2]);
Assert.Equal("Ace", values[3]);
StringWriter stringWriter = new StringWriter();
SeparatedValueWriter writer = new SeparatedValueWriter(stringWriter, outerSchema);
writer.Write(values);
string output = stringWriter.GetStringBuilder().ToString();
Assert.Equal(message, output);
}
public void TestGetSchema_SchemaProvided_ParsesValues_Quoted()
{
const string text = "123,\"Bob\",1/19/2013";
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader, schema);
Assert.True(parser.Read(), "The first record was skipped.");
object[] actual = parser.GetValues();
object[] expected = new object[] { 123, "Bob", new DateTime(2013, 1, 19) };
Assert.Equal(expected, actual);
}
public IEnumerable <int[]> GetData(string filePath, string separator = ";")
{
using (StreamReader streamReader = new StreamReader(filePath))
{
SeparatedValueOptions options = new SeparatedValueOptions()
{
IsFirstRecordSchema = false, Separator = separator, Quote = '\''
};
SeparatedValueReader reader = new SeparatedValueReader(streamReader, options);
List <int[]> values = new List <int[]>();
while (reader.Read())
{
var actualValues = reader.GetValues();
values.Add(Array.ConvertAll(actualValues, x => Convert.ToInt32(x)));
}
return(values);
}
}
public void ShouldSubstituteBadValues_CSV()
{
const string data = @"ABC,2018-02-30,{1234-5678-9123-000000}";
var stringReader = new StringReader(data);
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("Int32"));
schema.AddColumn(new DateTimeColumn("DateTime"));
schema.AddColumn(new GuidColumn("Guid"));
var csvReader = new SeparatedValueReader(stringReader, schema);
csvReader.ColumnError += (sender, e) =>
{
if (e.ColumnContext.ColumnDefinition.ColumnName == "Int32")
{
e.Substitution = 1;
e.IsHandled = true;
}
else if (e.ColumnContext.ColumnDefinition.ColumnName == "DateTime")
{
e.Substitution = new DateTime(2018, 07, 08);
e.IsHandled = true;
}
else if (e.ColumnContext.ColumnDefinition.ColumnName == "Guid")
{
e.Substitution = Guid.Empty;
e.IsHandled = true;
}
};
Assert.IsTrue(csvReader.Read(), "Could not read the first record.");
var values = csvReader.GetValues();
var expected = new object[] { 1, new DateTime(2018, 07, 08), Guid.Empty };
CollectionAssert.AreEqual(expected, values, "The wrong values were substituted.");
Assert.IsFalse(csvReader.Read(), "Read too many records.");
}
public void TestRead_EmbeddedQuote_ParsesCorrectly()
{
var text = @"123;Todd's Bait Shop;1/17/2014";
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"));
schema.AddColumn(new StringColumn("name"));
schema.AddColumn(new DateTimeColumn("created"));
var options = new SeparatedValueOptions
{
IsFirstRecordSchema = false,
Separator = ";"
};
StringReader stringReader = new StringReader(text);
var reader = new SeparatedValueReader(stringReader, schema, options);
var result = reader.Read();
Assert.True(result, "Could not read the record.");
object[] expected = { 123, "Todd's Bait Shop", new DateTime(2014, 1, 17) };
object[] actual = reader.GetValues();
Assert.Equal(expected, actual);
}
public void TestRead_MultipleCallsToValues_ReturnsSameValues()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
string[] expected = new string[] { "a", "b", "c" };
object[] actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The same values were not returned multiple times.");
}
public void TestRead_GetValuesWithoutReading_Throws()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
parser.GetValues();
}
public void TestRead_RecordWithCP1252Characters_ReturnsCorrectCharacters()
{
//---- Arrange -----------------------------------------------------
// Need to convert the string to target encoding because otherwise a string declared in VS will always be encoded as UTF-8
var text = Encoding.Convert(Encoding.UTF8, Encoding.GetEncoding(1252), Encoding.UTF8.GetBytes(@"123;Müller;1/17/2014"));
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id")).AddColumn(new StringColumn("name")).AddColumn(new DateTimeColumn("created"));
var options = new SeparatedValueOptions
{
IsFirstRecordSchema = false,
Separator = ";" ,
Encoding = Encoding.GetEncoding(1252)
};
var testee = new SeparatedValueReader(new MemoryStream(text), schema, options);
//---- Act ---------------------------------------------------------
var result = testee.Read();
//---- Assert ------------------------------------------------------
Assert.IsTrue(result, "Could not read the record.");
object[] expected = { 123, "Müller", new DateTime(2014, 1, 17) };
object[] actual = testee.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
}
private static void assertValues(SeparatedValueReader reader, string firstName, string lastName, string street, string city, string state, string zip)
{
object[] values = reader.GetValues();
Assert.Equal(6, values.Length);
Assert.Equal(firstName, values[0]);
Assert.Equal(lastName, values[1]);
Assert.Equal(street, values[2]);
Assert.Equal(city, values[3]);
Assert.Equal(state, values[4]);
Assert.Equal(zip, values[5]);
}
public void TestRead_SingleRecord_ReturnsTrueOnce()
{
const string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
string[] expected = new string[] { "a", "b", "c" };
object[] actual = parser.GetValues();
CollectionAssert.AreEqual(expected, actual, "The wrong values were parsed.");
canRead = parser.Read();
Assert.IsFalse(canRead, "No more records should have been read.");
}
public void TestGetSchema_FirstRecordSchema_TooManyColumns_IgnoresTrailing()
{
const string text = @"id,name,created
123,Bob,1/19/2013,Hello";
StringReader stringReader = new StringReader(text);
SeparatedValueOptions options = new SeparatedValueOptions() { IsFirstRecordSchema = true };
SeparatedValueReader parser = new SeparatedValueReader(stringReader, options);
Assert.True(parser.Read(), "The record could not be read.");
Assert.Equal(parser.GetSchema().ColumnDefinitions.Count, parser.GetValues().Length);
;
}
public void TestRead_SingleRecord_ReturnsTrueOnce()
{
const string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
object[] expected = new object[] { "a", "b", "c" };
object[] actual = parser.GetValues();
Assert.Equal(expected, actual);
canRead = parser.Read();
Assert.False(canRead, "No more records should have been read.");
}
public void TestRead_ValuesAfterEndOfFile_Throws()
{
string text = "a,b,c";
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)));
bool canRead = parser.Read();
Assert.IsTrue(canRead, "Could not read the record.");
canRead = parser.Read();
Assert.IsFalse(canRead, "We should have reached the end of the file.");
parser.GetValues();
}
public void TestGetValues_BlankTrailingSection_ReturnsNull()
{
using (MemoryStream stream = new MemoryStream())
{
SeparatedValueOptions options = new SeparatedValueOptions() { IsFirstRecordSchema = true };
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created") { InputFormat = "M/d/yyyy", OutputFormat = "M/d/yyyy" })
.AddColumn(new StringColumn("trailing"));
object[] sources = new object[] { 123, "Bob", new DateTime(2013, 1, 19), "" };
using (SeparatedValueWriter builder = new SeparatedValueWriter(stream, schema, options))
{
builder.Write(sources);
}
stream.Position = 0;
SeparatedValueReader parser = new SeparatedValueReader(stream, schema, options);
Assert.IsTrue(parser.Read(), "No records were found.");
object[] values = parser.GetValues();
Assert.AreEqual(schema.ColumnDefinitions.Count, values.Length, "The wrong number of values were read.");
Assert.AreEqual(sources[0], values[0], "The first column was not parsed correctly.");
Assert.AreEqual(sources[1], values[1], "The second column was not parsed correctly.");
Assert.AreEqual(sources[2], values[2], "The third column was not parsed correctly.");
Assert.AreEqual(null, values[3], "The forth column was not interpreted as null.");
Assert.IsFalse(parser.Read(), "Too many records were found.");
}
}
public void TestRead_MultipleCallsToValues_ReturnsSameValues()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
object[] expected = new object[] { "a", "b", "c" };
object[] actual = parser.GetValues();
Assert.Equal(expected, actual);
actual = parser.GetValues();
Assert.Equal(expected, actual);
}
public void TestRead_GetValuesWithoutReading_Throws()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
Assert.Throws<InvalidOperationException>(() => parser.GetValues());
}
public void TestRead_EmbeddedQuote_ParsesCorrectly()
{
var text = @"123;Todd's Bait Shop;1/17/2014";
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"));
schema.AddColumn(new StringColumn("name"));
schema.AddColumn(new DateTimeColumn("created"));
var options = new SeparatedValueOptions
{
IsFirstRecordSchema = false,
Separator = ";"
};
StringReader stringReader = new StringReader(text);
var reader = new SeparatedValueReader(stringReader, schema, options);
var result = reader.Read();
Assert.True(result, "Could not read the record.");
object[] expected = { 123, "Todd's Bait Shop", new DateTime(2014, 1, 17) };
object[] actual = reader.GetValues();
Assert.Equal(expected, actual);
}
public void TestGetValues_BlankTrailingSection_ReturnsNull()
{
SeparatedValueOptions options = new SeparatedValueOptions() { IsFirstRecordSchema = true };
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created") { InputFormat = "M/d/yyyy", OutputFormat = "M/d/yyyy" })
.AddColumn(new StringColumn("trailing"));
object[] sources = new object[] { 123, "Bob", new DateTime(2013, 1, 19), "" };
StringWriter stringWriter = new StringWriter();
SeparatedValueWriter builder = new SeparatedValueWriter(stringWriter, schema, options);
builder.Write(sources);
StringReader stringReader = new StringReader(stringWriter.ToString());
SeparatedValueReader parser = new SeparatedValueReader(stringReader, schema, options);
Assert.True(parser.Read(), "No records were found.");
object[] values = parser.GetValues();
Assert.Equal(schema.ColumnDefinitions.Count, values.Length);
Assert.Equal(sources[0], values[0]);
Assert.Equal(sources[1], values[1]);
Assert.Equal(sources[2], values[2]);
Assert.Equal(null, values[3]);
Assert.False(parser.Read(), "Too many records were found.");
}
public void TestGetSchema_SchemaProvided_ParsesValues_Quoted()
{
const string text = "123,\"Bob\",1/19/2013";
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader, schema);
Assert.True(parser.Read(), "The first record was skipped.");
object[] actual = parser.GetValues();
object[] expected = new object[] { 123, "Bob", new DateTime(2013, 1, 19) };
Assert.Equal(expected, actual);
}
public void TestRead_ZeroLengthColumn()
{
//---- Arrange -----------------------------------------------------
var text = "104\t20\t1000\t00\tLausanne\tLausanne\tVD\t2\t\t0\t130\t5586\t19880301";
var options = new SeparatedValueOptions { IsFirstRecordSchema = false, Separator = "\t" };
var schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("OnrpId"))
.AddColumn(new Int32Column("Type"))
.AddColumn(new Int32Column("ZipCode"))
.AddColumn(new StringColumn("ZipCodeAddOn"))
.AddColumn(new StringColumn("TownShortName"))
.AddColumn(new StringColumn("TownOfficialName"))
.AddColumn(new StringColumn("CantonAbbreviation"))
.AddColumn(new Int16Column("MainLanguageCode"))
.AddColumn(new Int16Column("OtherLanguageCode"))
.AddColumn(new ByteColumn("HasSortfileData"))
.AddColumn(new Int32Column("LetterServiceOnrpId"))
.AddColumn(new Int32Column("MunicipalityId"))
.AddColumn(new StringColumn("ValidFrom"));
StringReader stringReader = new StringReader(text);
var testee = new SeparatedValueReader(stringReader, options);
//---- Act ---------------------------------------------------------
var result = testee.Read();
//---- Assert ------------------------------------------------------
Assert.True(result);
Assert.Equal(schema.ColumnDefinitions.Count, testee.GetValues().Count());
}
public void TestGetSchema_SchemaProvided_ParsesValues()
{
const string text = @"123,Bob,1/19/2013";
SeparatedValueSchema schema = new SeparatedValueSchema();
schema.AddColumn(new Int32Column("id"))
.AddColumn(new StringColumn("name"))
.AddColumn(new DateTimeColumn("created"));
SeparatedValueReader parser = new SeparatedValueReader(new MemoryStream(Encoding.Default.GetBytes(text)), schema);
Assert.IsTrue(parser.Read(), "The first record was skipped.");
object[] actual = parser.GetValues();
object[] expected = new object[] { 123, "Bob", new DateTime(2013, 1, 19) };
CollectionAssert.AreEqual(expected, actual, "The values were not parsed as expected.");
}
public void TestRead_ValuesAfterEndOfFile_Throws()
{
string text = "a,b,c";
StringReader stringReader = new StringReader(text);
SeparatedValueReader parser = new SeparatedValueReader(stringReader);
bool canRead = parser.Read();
Assert.True(canRead, "Could not read the record.");
canRead = parser.Read();
Assert.False(canRead, "We should have reached the end of the file.");
Assert.Throws<InvalidOperationException>(() => parser.GetValues());
}
