public void ParsingTest19()
{
string data = String.Empty;
using var csv = ReadCsv.FromString(data);
Assert.IsFalse(csv.Read());
}
public void FieldCountTest1()
{
using var csv = ReadCsv.FromString(CsvReaderSampleData.SampleData1,
trimmingOptions: ValueTrimmingOptions.UnquotedOnly
);
CsvReaderSampleData.CheckSampleData1(csv, false, true);
}
public UIWindowsData(ReadCsv config, int row)
{
_id = int.Parse(config.GetDataByRowAndName(row, "ID"));
_name = config.GetDataByRowAndName(row, "WindowName");
_opentype = int.Parse(config.GetDataByRowAndName(row, "OpenType"));
_prefabsPath = config.GetDataByRowAndName(row, "PrefabPath");
}
public void LastFieldEmptyFollowedByMissingFieldsOnNextRecord()
{
const string Data = "a,b,c,d,e"
+ "\na,b,c,d,"
+ "\na,b,";
using (var csv = ReadCsv.FromString(Data, missingFieldAction: MissingFieldAction.ReplaceByNull))
{
var record = new string[5];
Assert.IsTrue(csv.Read());
csv.GetValues(record);
CollectionAssert.AreEqual(new string[] { "a", "b", "c", "d", "e" }, record);
Assert.IsTrue(csv.Read());
csv.GetValues(record);
CollectionAssert.AreEqual(new string[] { "a", "b", "c", "d", "" }, record);
Assert.IsTrue(csv.Read());
csv.GetValues(record);
CollectionAssert.AreEqual(new string[] { "a", "b", "", null, null }, record);
Assert.IsFalse(csv.Read());
}
}
public void FileReaderTest_ReadSimpleCSVs(string testFileName)
{
// Arrange
var jsonSettings = @"
{
""importFiles"":
[
{
""file"": ""..\\..\\..\\..\\TestCsv\\{0}"",
""batchSize"": 4
}
]
}";
var jsettings = jsonSettings.Replace("{0}", testFileName);
var importTasks = (List <ImportFileOptions>)CsvToSql.Configuration.ImportTasks.ReadTasks(log, jsettings);
var csvReader = new ReadCsv(log);
var sqlWriter = new SqlServerWriterMoq(log);
var executor = new TaskExecutor(log, csvReader, sqlWriter);
// Act
int rowCnt = 0;
importTasks.ForEach(impTask => rowCnt += executor.Run(impTask));
// Assert
Assert.AreEqual(importTasks.Count, 1);
Assert.IsTrue(rowCnt > 4);
}
public void Given_FilePath_Null_Then_ConvertCsvToDataTable_Returns_Empty_DataTable()
{
string filePath = null;
DataTable dataTable = ReadCsv.ConvertCsvToDataTable(filePath);
Assert.IsTrue(dataTable.Rows.Count == 0);
}
public void GetSchemaTable_WithSchema_RetrievesCorrectlyTypedValues()
{
using (IDataReader csv = ReadCsv.FromString(CsvReaderSampleData.SampleTypedData1,
hasHeaders: true, schema: CsvReaderSampleData.SampleTypedData1Schema))
{
csv.Read();
Assert.AreEqual(true, csv["System.Boolean"]);
Assert.AreEqual(new DateTime(2001, 11, 15), csv["System.DateTime"]);
Assert.AreEqual(1, csv["System.Single"]);
Assert.AreEqual(1.1, csv["System.Double"]);
Assert.AreEqual(1.10d, csv["System.Decimal"]);
Assert.AreEqual(1, csv["System.Int16"]);
Assert.AreEqual(1, csv["System.Int32"]);
Assert.AreEqual(1, csv["System.Int64"]);
Assert.AreEqual(1, csv["System.UInt16"]);
Assert.AreEqual(1, csv["System.UInt32"]);
Assert.AreEqual(1, csv["System.UInt64"]);
Assert.AreEqual(1, csv["System.Byte"]);
Assert.AreEqual(1, csv["System.SByte"]);
Assert.AreEqual('a', csv["System.Char"]);
Assert.AreEqual("abc", csv["System.String"]);
Assert.AreEqual(Guid.Parse("{11111111-1111-1111-1111-111111111111}"), csv["System.Guid"]);
Assert.AreEqual(null, csv["System.DBNull"]);
}
}
public void StandDevQueryTest()
{
myList = ReadCsv.ReadCsvFile <CitiesImportModel, CityMap>(path, doubleTypeConversion);
double standDev = Queries.StandDevQuery(myList, cityType);
Assert.AreEqual(350.4383, Math.Round(standDev, 4, MidpointRounding.AwayFromZero));
}
static void ReadFileAsCsvTest()
{
var reader = ReadCsv.FromFile(
"test.csv",
encoding: Encoding.UTF8,
delimiter: ';',
hasHeaders: true
);
using (reader)
{
var table = reader.GetSchemaTable();
var headerNames = (
from row in reader.GetSchemaTable().Rows.OfType <DataRow>()
select(string) row["ColumnName"]
).ToList();
while (reader.Read())
{
var item = new
{
First = reader["First"],
Last = reader["Last"],
BirthDate = Convert.ToDateTime(reader["BirthDate"]),
Quantity = Convert.ToInt32(reader["Quantity"]),
Price = Convert.ToDecimal(reader["Price"])
};
Console.WriteLine(item);
}
}
}
public async ValueTask <bool> ImportCsvAsync(string fileName, CancellationToken cancellationToken = default)
{
Logger.LogTrace("RepositoryBase ImportCsvAsync: " + fileName + " " + GetType().FullName + "." + System.Reflection.MethodBase.GetCurrentMethod()?.Name);
try
{
//var result = ReadCsv<TEntity>.ImportAsync(LoggerFactory, fileName, cancellationToken).ConfigureAwait(false);
DeleteRange(FindAll());
//Logger.LogTrace("DeleteRange OK.");
await foreach (var entity in ReadCsv <TEntity> .ImportAsync(LoggerFactory, fileName, cancellationToken).ConfigureAwait(false).WithCancellation(cancellationToken).ConfigureAwait(false))
{
var result = await AddAsync(entity, cancellationToken).ConfigureAwait(false);
//Logger.LogTrace("AddAsync OK. " + result.Entity.GetType().Name);
}
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex, GetType().FullName + "." + System.Reflection.MethodBase.GetCurrentMethod()?.Name + ": " + ex.Message);
}
return(false);
}
public void MissingFieldQuotedTest3()
{
const string Data = "a,b,c,d\n" +
"1,1,1,1\n" +
"2,\"2\"\n" +
"\"3\",3,3,3";
try
{
using (var csv = ReadCsv.FromString(Data))
{
while (csv.Read())
{
for (int i = 0; i < csv.FieldCount; i++)
{
string s = csv.GetString(i);
}
}
}
}
catch (MissingFieldCsvException ex)
{
Assert.AreEqual(new { LineNumber = 3L, FieldNumber = 2, ColumnNumber = 6 }, new { ex.LineNumber, ex.FieldNumber, ex.ColumnNumber });
}
}
public void WhenFileNotFoundThenThrowAnException()
{
string datafile = "FileNotPresent.csv";
ReadCsv.WhenReturnStringFromCsv(datafile, out bool status);
Assert.False(status);
}
public void EmptyString_WhenSkipEmptyLinesIsTrue_EmptyStringIsNotRead()
{
var data = "";
var result = ReadCsv.FromString(data, skipEmptyLines: true);
Assert.IsFalse(result.Read());
}
private static string[] Read(string data,
char quote = '"',
char delimiter = ',',
char escape = '"',
char comment = '#',
bool hasHeaders = false,
ValueTrimmingOptions trimmingOptions = ValueTrimmingOptions.None,
MissingFieldAction missingFieldAction = MissingFieldAction.ParseError,
QuotesInsideQuotedFieldAction quoteInsideQuotedFieldAction = QuotesInsideQuotedFieldAction.Ignore,
bool skipEmptyLines = false)
{
var reader = ReadCsv.FromString(data,
quote,
delimiter,
escape,
comment,
hasHeaders,
trimmingOptions,
missingFieldAction,
skipEmptyLines,
quoteInsideQuotedFieldAction);
reader.Read();
string[] results = new string[reader.FieldCount];
reader.GetValues(results);
return(results);
}
public async Task ImportCsvAsync()
{
var result = ReadCsv <Dto.TestClass> .ImportAsync(_loggerFactory, Path.Combine(
Directory.GetCurrentDirectory(), "Csv", "DtoTestClass.csv"));
Assert.NotNull(result);
CancellationToken cancellationToken = new CancellationToken();
var length = 0;
Dto.TestClass row = null;
await foreach (var item in result.WithCancellation(cancellationToken).ConfigureAwait(false))
{
if (length == 0)
{
row = item;
}
length++;
}
const int expected = 2;
const string expectedName = "Pippo";
Assert.Equal(expected, length);
Assert.Equal(expectedName, row.Name);
}
public void ParsingTest2()
{
// ["Bob said, ""Hey!""",2, 3 ]
const string data = "\"Bob said, \"\"Hey!\"\"\",2, 3 ";
using (var csv = ReadCsv.FromString(data, trimmingOptions: ValueTrimmingOptions.UnquotedOnly))
{
Assert.IsTrue(csv.Read());
Assert.AreEqual(@"Bob said, ""Hey!""", csv[0]);
Assert.AreEqual("2", csv[1]);
Assert.AreEqual("3", csv[2]);
Assert.IsFalse(csv.Read());
}
using (var csv = ReadCsv.FromString(data, trimmingOptions: ValueTrimmingOptions.None))
{
Assert.IsTrue(csv.Read());
Assert.AreEqual(@"Bob said, ""Hey!""", csv[0]);
Assert.AreEqual("2", csv[1]);
Assert.AreEqual(" 3 ", csv[2]);
Assert.IsFalse(csv.Read());
}
}
public ConfigDrop(ReadCsv config, int row)
{
_id = (int)float.Parse(config.GetDataByRowAndName(row, "ID"));
_sceneId = (int)float.Parse(config.GetDataByRowAndName(row, "Scene"));
_rate = (int)float.Parse(config.GetDataByRowAndName(row, "Rate"));
_gold = (int)float.Parse(config.GetDataByRowAndName(row, "Gold"));
string itemStr = config.GetDataByRowAndName(row, "Item");
if (!string.IsNullOrEmpty(itemStr))
{
string[] strs = itemStr.Split(';');
for (int i = 0; i < strs.Length; i++)
{
string[] item = strs[i].Split(',');
if (item.Length == 2)
{
DropData data;
data._itemId = (int)float.Parse(item[0]);
data._countMax = (int)float.Parse(item[1]);
_itemList.Add(data);
}
else
{
MyLog.LogError("drop[" + _id + "]'s items config error.");
}
}
}
}
public ExpandoObject CreateGameLogFromCsv(string csv)
{
var gameLog = new ExpandoObject();
using (var csvReader = ReadCsv.FromString(csv))
{
while (csvReader.Read())
{
for (var i = 0; i < _properties.Length; i++)
{
var added = gameLog.TryAdd(_properties[i], csvReader[i]);
if (!added)
{
throw new InvalidOperationException($"The property {_properties[i]} could not be added.");
}
}
var dyno = ((dynamic)gameLog);
var gameDate = dyno.game_date;
var gameYear = (string)gameDate.Substring(0, 4);
var gameMonth = (string)gameDate.Substring(4, 2);
var gameDay = (string)gameDate.Substring(6, 2);
gameLog.TryAdd("game_year", short.Parse(gameYear));
gameLog.TryAdd("game_month", byte.Parse(gameMonth));
gameLog.TryAdd("game_day", byte.Parse(gameDay));
}
}
return(gameLog);
}
public void LoadConfigs()
{
//UIWindows配置表
ReadCsv config = new ReadCsv("UIWindows");
for (int i = 3; i < config.GetRow(); i++)
{
UIWindowsData data = new UIWindowsData(config, i);
this.UIWindowsDataDict_.Add(data._id, data);
}
//BattleSatge配置表
config = new ReadCsv("BattleSatge");
for (int i = 3; i < config.GetRow(); i++)
{
BattleSatgeConfigData data = new BattleSatgeConfigData(config, i);
this.BattleSatgeConfigDict.Add(data._id, data);
}
//HeroConfigData配置表
config = new ReadCsv("Hero");
for (int i = 3; i < config.GetRow(); i++)
{
HeroConfigData data = new HeroConfigData(config, i);
this.HeroConfigDict.Add(data._id, data);
}
}
// GET api/values/5
public string Get(int id)
{
ReadCsv aasd = new ReadCsv();
aasd.ReadExcel();
return(id + "");
}
public void MockDataTable4()
{
var readerCsv = new ReadCsv();
var dataPrototypeTable2 = readerCsv.MockPrototypeDataTable2().OrderBy(it => it.IdArea).ToList();
ScoreAreaCollection.InsertMany(dataPrototypeTable2);
}
public void BooleanValue_SerializedAsYesOrNo_WhenYes_IsTrue()
{
var data = "yes";
var reader = ReadCsv.FromString(data, schema: new CsvSchemaBuilder().AddBoolean("BooleanColumn", "yes", "no", false).Schema);
reader.Read();
Assert.AreEqual(true, reader[0]);
}
public void BooleanValue_SerializedAsYesOrNo_WhenInvalid_Throws()
{
var data = "foo";
var reader = ReadCsv.FromString(data, schema: new CsvSchemaBuilder().AddBoolean("BooleanColumn", "yes", "no", false).Schema);
reader.Read();
Assert.Throws <FormatException>(() => _ = reader[0]);
}
public void WhenSchemaImplicitlyCreatedFromClass_ExpectedValuesAreReturned()
{
var item = ReadCsv
.FromString <MyClass>(input, delimiter: ';', hasHeaders: true)
.Single();
Verify(item);
}
public void ReadCsvFileTest()
{
var readCsv = new ReadCsv();
readCsv.ReadCsvFile();
//3 rows in test file
Assert.AreEqual(3, readCsv.ReadCsvFile().Count);
}
public IActionResult UploadFromCsv()
{
ReadCsv csvReader = new ReadCsv();
var allLinks = csvReader.result;
LoadCsv csvLoader = new LoadCsv(allLinks, _itemData);
return(RedirectToAction(nameof(List)));
}
public void Depth_WhenClosed_ReturnsZero()
{
using var reader = ReadCsv.FromString(
CsvReaderSampleData.SampleData1, hasHeaders: true);
reader.Read();
reader.Close();
Assert.AreEqual(0, reader.Depth);
}
public void ReadCsvTest()
{
var path = "c://csvfiles//worldcities.csv";
var doubleTypeConversion = new DoubleConversion();
myList = ReadCsv.ReadCsvFile <CitiesImportModel, CityMap>(path, doubleTypeConversion);
Assert.IsNotNull(myList);
}
public void ReadCsvFileTest()
{
var path = "c://csvfiles//worldcities.csv";
var doubleTypeConversion = new DoubleConversion();
IList <CityModelImport> myList = ReadCsv.ReadCsvFile <CityModelImport, CityMap>(path, doubleTypeConversion);
Assert.AreEqual(15493, myList.Count());
}
public void Depth_IsAlwaysZero()
{
using var reader = ReadCsv.FromString(
CsvReaderSampleData.SampleData1, hasHeaders: true);
Assert.AreEqual(0, reader.Depth);
reader.Read();
Assert.AreEqual(0, reader.Depth);
}
