public void CreateConverterTest8(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.ByteArray, false, false, throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(Base64Converter));
Assert.AreEqual(typeof(byte[]), conv.Type);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
if (conv.FallbackValue is byte[] bts)
{
Assert.AreEqual(0, bts.Length);
}
else
{
Assert.Fail();
}
var test1 = new byte[] { 17, 24, 42 };
string?s = conv.ConvertToString(test1);
byte[]? test2 = (byte[]?)conv.Parse(s);
CollectionAssert.AreEqual(test1, test2);
}
public void StringConverterTest()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.String, false);
Assert.IsNotNull(conv.FallbackValue);
Assert.AreEqual(typeof(string), conv.Type);
Assert.IsFalse(conv.ThrowsOnParseErrors);
}
public void ParseTest(string s)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTime);
var dt = conv.Parse(s);
Assert.AreEqual(new DateTime(1972, 01, 31), dt);
}
public void RoundtripTest5()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>(ignoreCase: false, throwOnParseErrors: true);
string s = CsvTypeCode.DateTimeOffset.ToString().ToUpperInvariant();
_ = (CsvTypeCode?)conv.Parse(s);
}
public void ParseTest3()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.ByteArray, true, throwOnParseErrors: false);
Assert.IsInstanceOfType(conv, typeof(Base64Converter));
Assert.IsNull(conv.FallbackValue);
Assert.IsNull(conv.Parse("blabla"));
}
/// <summary>
/// Initialisiert ein neues <see cref="CsvIndexProperty"/>-Objekt.
/// </summary>
/// <param name="propertyName">Der Bezeichner unter dem die Eigenschaft angesprochen wird. Er muss den Regeln für C#-Bezeichner
/// entsprechen. Es werden nur ASCII-Zeichen akzeptiert.</param>
/// <param name="csvColumnIndex">Nullbasierter Index der Spalte der CSV-Datei.</param>
/// <param name="converter">Der <see cref="ICsvTypeConverter"/>, der die Typkonvertierung übernimmt.</param>
///
/// <exception cref="ArgumentException"><paramref name="propertyName"/> entspricht nicht den Regeln für C#-Bezeichner (nur
/// ASCII-Zeichen).</exception>
///
/// <exception cref="ArgumentNullException"><paramref name="propertyName"/> oder
/// <paramref name="converter"/> ist <c>null</c>.</exception>
///
/// <exception cref="ArgumentOutOfRangeException"><paramref name="csvColumnIndex"/> ist kleiner als 0.</exception>
public CsvIndexProperty(
string propertyName, int csvColumnIndex, ICsvTypeConverter converter) :
base(propertyName, new string[] { AutoColumnName.Create(csvColumnIndex) }, converter)
{
if (csvColumnIndex < 0)
{
throw new ArgumentOutOfRangeException(nameof(csvColumnIndex));
}
}
public void ParseTest1()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.ByteArray, true);
Assert.IsInstanceOfType(conv, typeof(Base64Converter));
Assert.IsNull(conv.FallbackValue);
Assert.IsNull(conv.Parse(null));
}
public void RoundtripTest10(bool throwOnParseErrors, bool ignoreCase, bool nullable)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>(nullable, true, throwOnParseErrors, ignoreCase);
string?s = conv.ConvertToString(DBNull.Value);
Assert.IsNull(s);
Assert.IsTrue(Convert.IsDBNull(conv.Parse(s)));
}
public void ConvertToStringTest2()
{
var dt = new DateTime(1972, 01, 31);
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTime);
//dt = dt.ToLocalTime();
string?s = conv.ConvertToString(dt);
Assert.IsNotNull(s);
}
public void CreateHexConverterTest2(
CsvTypeCode typeCode,
bool nullable,
bool throwOnParseErrors,
Type converterType)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateHexConverter(typeCode, nullable, true, throwOnParseErrors);
Assert.AreEqual(converterType, conv.Type);
Assert.IsTrue(Convert.IsDBNull(conv.FallbackValue));
Assert.AreEqual(throwOnParseErrors, conv.ThrowsOnParseErrors);
}
public void RoundtripTest8(bool throwOnParseErrors, bool ignoreCase)
{
CsvTypeCode?val = null;
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>(true, false, throwOnParseErrors, ignoreCase);
string?s = conv.ConvertToString(val);
Assert.IsNull(s);
Assert.IsNull(conv.Parse(s));
}
public void ConvertToStringTest()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.String, true, true);
Assert.IsNull(conv.ConvertToString(DBNull.Value));
Assert.IsNull(conv.ConvertToString(null));
const string test = "Test";
Assert.AreEqual(test, conv.ConvertToString(test));
}
public void CreateConverterTest2(
CsvTypeCode typeCode,
bool nullable,
bool throwOnParseErrors,
Type converterType,
object?fallBackValue)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(typeCode, nullable, false, throwOnParseErrors: throwOnParseErrors);
Assert.AreEqual(converterType, conv.Type);
Assert.AreEqual(fallBackValue, conv.FallbackValue);
Assert.AreEqual(throwOnParseErrors, conv.ThrowsOnParseErrors);
}
public void ParseTest()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.String, true);
Assert.IsNull(conv.Parse(null));
conv = CsvConverterFactory.CreateConverter(CsvTypeCode.String, false);
Assert.IsNotNull(conv.Parse(null));
const string test = "Test";
Assert.AreEqual(test, conv.Parse(test));
}
public void RoundtripTest2()
{
CsvTypeCode val = CsvTypeCode.DateTimeOffset;
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>("F");
string?s = conv.ConvertToString(val);
Assert.IsNotNull(s);
var val2 = (CsvTypeCode?)conv.Parse(s);
Assert.AreEqual(val, val2);
}
public void Roundtrip1()
{
TimeSpan now = DateTime.UtcNow.TimeOfDay;
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.TimeSpan);
string?tmp = conv.ConvertToString(now);
Assert.IsNotNull(tmp);
var now2 = (TimeSpan?)conv.Parse(tmp);
Assert.AreEqual(now, now2);
}
public void Roundtrip1()
{
var guid = Guid.NewGuid();
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.Guid);
string?tmp = conv.ConvertToString(guid);
Assert.IsNotNull(tmp);
var now2 = (Guid?)conv.Parse(tmp);
Assert.AreEqual(guid, now2);
}
public void RoundtripTest2()
{
int i = 123456789;
ICsvTypeConverter conv = CsvConverterFactory.CreateHexConverter(CsvTypeCode.Int32);
string?s = conv.ConvertToString(i)?.ToLowerInvariant();
Assert.IsNotNull(s);
var i2 = (int?)conv.Parse(s);
Assert.AreEqual(i, i2);
}
public void RoundtripTest1()
{
double d = 72.81;
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.Double);
string?s = conv.ConvertToString(d);
Assert.IsNotNull(s);
double?d2 = (double?)conv.Parse(s);
Assert.AreEqual(d, d2);
}
public AccessBenchmark()
{
_csv = Properties.Resources.Test1;
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.String);
_indexWrapper = new CsvRecordWrapper();
_indexWrapper.AddProperty(new CsvIndexProperty("Column0", 0, conv));
_indexWrapper.AddProperty(new CsvIndexProperty("Column1", 1, conv));
_indexWrapper.AddProperty(new CsvIndexProperty("Column2", 2, conv));
_nameWrapper = new CsvRecordWrapper();
_nameWrapper.AddProperty(new CsvProperty("Column0", new string[] { "Column0" }, conv));
_nameWrapper.AddProperty(new CsvProperty("Column1", new string[] { "Column1" }, conv));
_nameWrapper.AddProperty(new CsvProperty("Column2", new string[] { "Column2" }, conv));
}
public void RoundtripTest6()
{
CsvTypeCode val = CsvTypeCode.DateTimeOffset;
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>("F", ignoreCase: false, throwOnParseErrors: true);
string?s = conv.ConvertToString(val);
Assert.IsNotNull(s);
s = s !.ToUpperInvariant();
_ = (CsvTypeCode?)conv.Parse(s);
}
public void Roundtrip1()
{
DateTimeOffset now = new DateTime(2021, 3, 1, 17, 25, 38, DateTimeKind.Local);
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTimeOffset);
string?tmp = conv.ConvertToString(now);
Assert.IsNotNull(tmp);
var now2 = (DateTimeOffset?)conv.Parse(tmp);
Assert.AreEqual(now, now2);
}
public void RoundtripTest3()
{
CsvTypeCode val = CsvTypeCode.DateTimeOffset;
ICsvTypeConverter conv = CsvConverterFactory.CreateEnumConverter <CsvTypeCode>(ignoreCase: true);
string?s = conv.ConvertToString(val);
Assert.IsNotNull(s);
s = s !.ToUpperInvariant();
var val2 = (CsvTypeCode?)conv.Parse(s);
Assert.AreEqual(val, val2);
}
public void DateTimeOffsetConverterTest0()
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTimeOffset);
Assert.IsInstanceOfType(conv, typeof(DateTimeOffsetConverter));
var dt = new DateTime(1975, 07, 14);
string?s = conv.ConvertToString(new DateTimeOffset(dt));
Assert.IsNotNull(s);
var dto = (DateTimeOffset)conv.Parse(s) !;
Assert.AreEqual(dt, dto.DateTime);
}
public void RoundtripTest1()
{
var bytes = new byte[7];
using var rnd = RandomNumberGenerator.Create();
rnd.GetBytes(bytes);
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.ByteArray);
string?s = conv.ConvertToString(bytes);
Assert.IsNotNull(s);
var bytes2 = (byte[]?)conv.Parse(s);
CollectionAssert.AreEqual(bytes, bytes2);
}
public void CreateConverterTest9(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.Guid, false, false, throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(GuidConverter));
Assert.AreEqual(typeof(Guid), conv.Type);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
Assert.AreEqual(conv.FallbackValue, default(Guid));
var test1 = Guid.NewGuid();
string?s = conv.ConvertToString(test1);
var test2 = (Guid?)conv.Parse(s);
Assert.AreEqual(test1, test2);
}
public void CreateConverterTest15(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTimeOffset, false, false, CultureInfo.CreateSpecificCulture("de-DE"), throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(DateTimeOffsetConverter));
Assert.AreEqual(typeof(DateTimeOffset), conv.Type);
Assert.AreEqual(default(DateTimeOffset), conv.FallbackValue);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
var test = new DateTimeOffset(1956, 12, 24, 14, 27, 32, TimeSpan.FromHours(3));
string?s = conv.ConvertToString(test);
Assert.IsNotNull(s);
var test2 = (DateTimeOffset?)conv.Parse(s);
Assert.AreEqual(test, test2);
}
public void CreateConverterTest12(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.DateTime, false, false, CultureInfo.InvariantCulture, throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(DateTimeConverter));
Assert.AreEqual(typeof(DateTime), conv.Type);
Assert.AreEqual(default(DateTime), conv.FallbackValue);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
var test = new DateTime(1956, 12, 24, 14, 27, 32);
string?s = conv.ConvertToString(test);
Assert.IsNotNull(s);
var test2 = (DateTime?)conv.Parse(s);
Assert.AreEqual(test, test2);
}
public void CreateConverterTest17(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.TimeSpan, false, false, CultureInfo.CreateSpecificCulture("de-DE"), throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(TimeSpanConverter));
Assert.AreEqual(typeof(TimeSpan), conv.Type);
Assert.AreEqual(default(TimeSpan), conv.FallbackValue);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
var test = new TimeSpan(16, 24, 53);
string?s = conv.ConvertToString(test);
Assert.IsNotNull(s);
var test2 = (TimeSpan?)conv.Parse(s);
Assert.AreEqual(test, test2);
}
public void CreateConverterTest7(bool throwsOnParseErrors)
{
ICsvTypeConverter conv = CsvConverterFactory.CreateConverter(CsvTypeCode.Decimal, false, false, CultureInfo.CreateSpecificCulture("de-DE"), throwOnParseErrors: throwsOnParseErrors);
Assert.IsInstanceOfType(conv, typeof(NumberConverter <decimal>));
Assert.AreEqual(typeof(decimal), conv.Type);
Assert.AreEqual(default(decimal), conv.FallbackValue);
Assert.AreEqual(throwsOnParseErrors, conv.ThrowsOnParseErrors);
decimal test = 57.839m;
string? s = conv.ConvertToString(test);
Assert.IsNotNull(s);
decimal?test2 = (decimal?)conv.Parse(s);
Assert.AreEqual(test, test2);
}
