public void ReadTest()
{
var queue = new Queue <string[]>();
queue.Enqueue(new[] { "Names" });
queue.Enqueue(new[] { "one" });
queue.Enqueue(null);
var parserMock = new ParserMock(queue);
var csv = new CsvReader(parserMock);
csv.Read();
try
{
csv.GetRecord <Test>();
Assert.Fail();
}
catch (CsvTypeConverterException)
{
}
}
public void GetRecords_WithBooleanFalseValuesAttribute_HasHeader_CreatesRecords()
{
var rows = new Queue <string[]>(new List <string[]>
{
new [] { "id", "name" },
new [] { "1", "NULL" },
null
});
using (var parser = new ParserMock(rows))
using (var csv = new CsvReader(parser))
{
csv.Configuration.RegisterClassMap <FooMap>();
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.IsNull(records[0].Name);
}
}
public void GetRecords_WithBooleanFalseValuesAttribute_NoHeader_CreatesRecords()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", "Bar" },
};
using (var csv = new CsvReader(parser))
{
var records = csv.GetRecords <Foo>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.False(records[0].Boolean);
}
}
public void Read_NoHeader_HasParameterAttribute_Reads()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", "one" }
};
using (var csv = new CsvReader(parser))
{
var records = csv.GetRecords <FooParameterAttribute>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.Equal("one", records[0].Name);
}
}
public void GetRecords_WithDefaultAttributes_NoHeader_CreatesRecords()
{
var rows = new Queue <string[]>(new List <string[]>
{
new [] { "1", "" },
null
});
using (var parser = new ParserMock(rows))
using (var csv = new CsvReader(parser))
{
csv.Configuration.HasHeaderRecord = false;
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.AreEqual("Bar", records[0].Name);
}
}
public void GetRecords_WithEnumIgnoreCaseAttributes_NoHeader_CreatesRecords()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", "one" },
};
using (var csv = new CsvReader(parser))
{
var records = csv.GetRecords <Foo>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.Equal(Bar.One, records[0].Bar);
}
}
public void GetRecords_WithParameterMap_HasHeader_CreatesRecords()
{
var rows = new Queue <string[]>(new List <string[]>
{
new [] { "id", "amount" },
new [] { "1", $"({amount})" },
null
});
using (var parser = new ParserMock(rows))
using (var csv = new CsvReader(parser))
{
var map = csv.Configuration.RegisterClassMap <FooMap>();
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.AreEqual(-amount, records[0].Amount);
}
}
public void GetRecords_WithDefaultAttributes_NoHeader_CreatesRecords()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", "" },
};
using (var csv = new CsvReader(parser))
{
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.AreEqual("Bar", records[0].Name);
}
}
public void ConstantIsNullTest()
{
var rows = new Queue <string[]>();
rows.Enqueue(new[] { "Id", "Name" });
rows.Enqueue(new[] { "1", "one" });
rows.Enqueue(new[] { "2", "two" });
rows.Enqueue(null);
var parser = new ParserMock(rows);
var csv = new CsvReader(parser);
csv.Configuration.RegisterClassMap <TestNullMap>();
var records = csv.GetRecords <Test>().ToList();
Assert.AreEqual(1, records[0].Id);
Assert.IsNull(records[0].Name);
Assert.AreEqual(2, records[1].Id);
Assert.IsNull(records[1].Name);
}
public void TryGetFieldInvalidIndexTest()
{
var data1 = new[] { "One", "Two" };
var data2 = new[] { "one", "two" };
var queue = new Queue <string[]>();
queue.Enqueue(data1);
queue.Enqueue(data2);
queue.Enqueue(null);
var parserMock = new ParserMock(queue);
var reader = new CsvReader(parserMock);
reader.Read();
var got = reader.TryGetField(0, out int field);
Assert.IsFalse(got);
Assert.AreEqual(default(int), field);
}
public void GetRecords_WithCultureInfoAttributes_NoHeader_CreatesRecords()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", $"({amount})" },
};
using (var csv = new CsvReader(parser))
{
var records = csv.GetRecords <Foo>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.Equal(-amount, records[0].Amount);
}
}
public void TryGetFieldStrictTest()
{
var parserMock = new ParserMock
{
new[] { "One", "Two" },
new[] { "1", "2" },
null
};
var reader = new CsvReader(parserMock);
reader.Read();
reader.ReadHeader();
reader.Read();
var got = reader.TryGetField("One", out int field);
Assert.True(got);
Assert.Equal(1, field);
}
public void HasHeaderRecordTest()
{
var parserMock = new ParserMock
{
{ "One", "Two" },
{ "1", "2" },
};
var reader = new CsvReader(parserMock);
reader.Read();
reader.ReadHeader();
reader.Read();
// Check to see if the header record and first record are set properly.
Assert.Equal(Convert.ToInt32("1"), reader.GetField <int>("One"));
Assert.Equal(Convert.ToInt32("2"), reader.GetField <int>("Two"));
Assert.Equal(Convert.ToInt32("1"), reader.GetField <int>(0));
Assert.Equal(Convert.ToInt32("2"), reader.GetField <int>(1));
}
public void RowTest()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parserMock = new ParserMock(config)
{
{ "1", "one" },
{ "2", "two" },
};
var csv = new CsvReader(parserMock);
csv.Read();
Assert.Equal(1, csv.Parser.Row);
csv.Read();
Assert.Equal(2, csv.Parser.Row);
}
public void GetMissingFieldByNameTest()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
MissingFieldFound = null,
};
var data1 = new[] { "One", "Two" };
var data2 = new[] { "1", "2" };
var parserMock = new ParserMock(config);
parserMock.Add(data1);
parserMock.Add(data2);
var reader = new CsvReader(parserMock);
reader.Read();
reader.ReadHeader();
Assert.Null(reader.GetField <string>("blah"));
}
public void ShouldSkipWithEmptyRows()
{
var rows = new Queue <string[]>();
rows.Enqueue(new[] { "First,Second" });
rows.Enqueue(new[] { "skipme," });
rows.Enqueue(new[] { "" });
rows.Enqueue(new[] { "1", "2" });
var parser = new ParserMock(rows);
var csv = new CsvReader(parser);
csv.Configuration.ShouldSkipRecord = row => row[0].StartsWith("skipme") || row.All(string.IsNullOrWhiteSpace);
csv.Read();
csv.Read();
Assert.AreEqual("1", csv.GetField(0));
Assert.AreEqual("2", csv.GetField(1));
}
public void GetOrdinalMissingTest()
{
var parser = new ParserMock
{
{ "Id", "Name" },
{ "1", "one" },
null,
};
using (var csv = new CsvReader(parser))
{
using (var dr = new CsvDataReader(csv))
{
Assert.ThrowsException <IndexOutOfRangeException>(() =>
{
dr.GetOrdinal("Foo");
});
}
}
}
public void GetRecords_WithParameterMap_NoHeader_CreatesRecords()
{
var rows = new Queue <string[]>(new List <string[]>
{
new [] { "1", "one" },
null
});
using (var parser = new ParserMock(rows))
using (var csv = new CsvReader(parser))
{
csv.Configuration.HasHeaderRecord = false;
csv.Configuration.RegisterClassMap <FooMap>();
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.AreEqual("one", records[0].Name);
}
}
public void OnlyFieldsTest()
{
var queue = new Queue <string[]>();
queue.Enqueue(new[] { "Name" });
queue.Enqueue(new[] { "name" });
queue.Enqueue(null);
var parserMock = new ParserMock(queue);
var reader = new CsvReader(parserMock);
try
{
// This needs a class map because auto mapping only works with properties.
reader.Configuration.RegisterClassMap <OnlyFieldsMap>();
reader.GetRecords <OnlyFields>().ToList();
Assert.Fail();
}
catch (CsvConfigurationException) {}
}
public void TryGetFieldTest()
{
var data1 = new[] { "One", "Two" };
var data2 = new[] { "1", "2" };
var queue = new Queue <string[]>();
queue.Enqueue(data1);
queue.Enqueue(data2);
queue.Enqueue(null);
var parserMock = new ParserMock(queue);
var reader = new CsvReader(parserMock);
reader.Read();
int field;
var got = reader.TryGetField(0, out field);
Assert.IsTrue(got);
Assert.AreEqual(1, field);
}
public void TrimHeadersTest()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
MissingFieldFound = null,
PrepareHeaderForMatch = args => args.Header.Trim(),
};
var parserMock = new ParserMock(config)
{
{ " one ", " two three " },
{ "1", "2" },
};
var reader = new CsvReader(parserMock);
reader.Read();
reader.ReadHeader();
reader.Read();
Assert.Equal("1", reader.GetField("one"));
Assert.Equal("2", reader.GetField("two three"));
Assert.Null(reader.GetField("twothree"));
}
public void SkipEmptyRowTest()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
ShouldSkipRecord = args => args.Row.Parser.Record.All(string.IsNullOrWhiteSpace),
};
var parser = new ParserMock(config)
{
{ "First,Second" },
{ " " },
{ "1", "2" },
};
var csv = new CsvReader(parser);
csv.Read();
csv.ReadHeader();
csv.Read();
Assert.Equal("1", csv.GetField(0));
Assert.Equal("2", csv.GetField(1));
}
public void GettingFieldHeadersFailsWhenHeaderNotReadTest()
{
var rows = new Queue <string[]>();
rows.Enqueue(new[] { "Id", "Name" });
rows.Enqueue(new[] { "1", "One" });
rows.Enqueue(new[] { "2", "two" });
rows.Enqueue(null);
var parser = new ParserMock(rows);
var csv = new CsvReader(parser);
try
{
var x = csv.FieldHeaders;
Assert.Fail();
}
catch (CsvReaderException)
{
}
}
public void Read_NoHeader_HasNameMap_Reads()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1", "one" }
};
using (var csv = new CsvReader(parser))
{
csv.Context.RegisterClassMap <FooMap>();
var records = csv.GetRecords <Foo>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.Equal("one", records[0].Name);
}
}
public void ReadHeaderResetsNamedIndexesTest()
{
var parser = new ParserMock
{
{ "Id", "Name" },
{ "Name", "Id" },
};
var csv = new CsvReader(parser);
csv.Read();
csv.ReadHeader();
Assert.Equal(0, csv.GetFieldIndex("Id"));
Assert.Equal(1, csv.GetFieldIndex("Name"));
csv.Read();
csv.ReadHeader();
Assert.Equal(1, csv.GetFieldIndex("Id"));
Assert.Equal(0, csv.GetFieldIndex("Name"));
}
public void GetOrdinalCaseInsensitiveTest()
{
var data = new List <string[]>
{
new[] { "Id", "Name" },
new[] { "1", "one" },
null,
};
var queue = new Queue <string[]>(data);
var parser = new ParserMock(queue);
using (var csv = new CsvReader(parser))
{
using (var dr = new CsvDataReader(csv))
{
var ordinal = dr.GetOrdinal("name");
Assert.AreEqual(1, ordinal);
}
}
}
public void HasHeaderRecordTest()
{
var data1 = new[] { "One", "Two" };
var data2 = new[] { "1", "2" };
var queue = new Queue <string[]>();
queue.Enqueue(data1);
queue.Enqueue(data2);
var parserMock = new ParserMock(queue);
var reader = new CsvReader(parserMock);
reader.Read();
// Check to see if the header record and first record are set properly.
Assert.AreEqual(Convert.ToInt32(data2[0]), reader.GetField <int>("One"));
Assert.AreEqual(Convert.ToInt32(data2[1]), reader.GetField <int>("Two"));
Assert.AreEqual(Convert.ToInt32(data2[0]), reader.GetField <int>(0));
Assert.AreEqual(Convert.ToInt32(data2[1]), reader.GetField <int>(1));
}
public void TryGetFieldIndexTest()
{
var parserMock = new ParserMock
{
{ "One", "Two", "Two" },
{ "1", "2", "3" }
};
var reader = new CsvReader(parserMock);
reader.Read();
int field;
var got = reader.TryGetField("Two", 0, out field);
Assert.IsTrue(got);
Assert.AreEqual(2, field);
got = reader.TryGetField("Two", 1, out field);
Assert.IsTrue(got);
Assert.AreEqual(3, field);
}
public void GetRecords_WithParameterMap_NoHeader_FieldMissing_CreatesRecords()
{
var config = new CsvConfiguration(CultureInfo.InvariantCulture)
{
HasHeaderRecord = false,
};
var parser = new ParserMock(config)
{
{ "1" },
};
using (var csv = new CsvReader(parser))
{
var map = csv.Context.RegisterClassMap <FooMap>();
var records = csv.GetRecords <Foo>().ToList();
Assert.Single(records);
Assert.Equal(1, records[0].Id);
Assert.Equal("Bar", records[0].Name);
}
}
public void ClassMap_AddParametersByIndex_CreatesRecords()
{
var rows = new Queue <string[]>(new List <string[]>
{
new [] { "Id", "Name" },
new [] { "1", "one" },
null
});
using (var parser = new ParserMock(rows))
using (var csv = new CsvReader(parser))
{
csv.Configuration.RegisterClassMap <FooMapByIndex>();
var records = csv.GetRecords <Foo>().ToList();
Assert.AreEqual(1, records.Count);
Assert.AreEqual(1, records[0].Id);
Assert.AreEqual("one", records[0].Name);
}
}
