public static void Extended(this ILogger logger, LogLevel logLevel, string message, object logProperties,
Exception ex = null, string exceptionTag = null)
{
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (ex == null)
{
ExtendedWithException(logger, logLevel, message, logProperties, null, 0, 0, null);
}
else if (ex.InnerException == null)
{
ExtendedWithException(logger, logLevel, message, logProperties, ex, 1, 1, null);
}
else
{
var allExceptions = ConvertException.ToList(ex);
if (string.IsNullOrEmpty(exceptionTag))
{
exceptionTag = Guid.NewGuid().ToString();
}
for (var index = 0; index < allExceptions.Count; index++)
{
ExtendedWithException(logger, logLevel, message, logProperties,
allExceptions[index], index + 1, allExceptions.Count, exceptionTag);
}
}
}
public void ExceptionFingerprintIsPresent()
{
Exception ex = new ApplicationException("test 1");
var fingerprint = ConvertException.ToFingerprint(ex);
AssertIsHash(fingerprint);
}
public void NullExceptionFingerprintIsEmpty()
{
Exception ex = null;
var fingerprint = ConvertException.ToFingerprint(ex);
Assert.That(fingerprint, Is.Empty);
}
public void DifferentMessageExceptionsHaveDifferentFingerprint()
{
Exception ex1 = new ApplicationException("test 1");
Exception ex2 = new ApplicationException("test 2");
var fingerprint1 = ConvertException.ToFingerprint(ex1);
var fingerprint2 = ConvertException.ToFingerprint(ex2);
AssertIsHash(fingerprint1);
AssertIsHash(fingerprint2);
Assert.That(fingerprint1, Is.Not.EqualTo(fingerprint2));
}
public void IdenticalStacktraceExceptionsHaveSameFingerprint()
{
Exception ex1 = PutStackTraceOnException(new ApplicationException("test 1"));
Exception ex2 = PutStackTraceOnException(new ApplicationException("test 1"));
var fingerprint1 = ConvertException.ToFingerprint(ex1);
var fingerprint2 = ConvertException.ToFingerprint(ex2);
AssertIsHash(fingerprint1);
AssertIsHash(fingerprint2);
Assert.That(fingerprint1, Is.EqualTo(fingerprint2));
}
public void IdenticalExceptionsFromDifferentLinesInAMethodHaveADifferentFingerprint()
{
Exception ex1 = PutStackTraceOnExceptionGeneric(new ApplicationException("test 1"), false, "Do stuff");
Exception ex2 = PutStackTraceOnExceptionGeneric(new ApplicationException("test 1"), true, "Do stuff");
var fingerprint1 = ConvertException.ToFingerprint(ex1);
var fingerprint2 = ConvertException.ToFingerprint(ex2);
AssertIsHash(fingerprint1);
AssertIsHash(fingerprint2);
Assert.That(fingerprint1, Is.Not.EqualTo(fingerprint2));
}
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
if (logEvent.Exception != null)
{
var text = ConvertException.ToFingerprint(logEvent.Exception);
builder.Append(text);
}
else
{
base.Append(builder, logEvent);
}
}
public override void GuardTypeSafety()
{
if (Nested == null || Nested.ReturnType == null)
{
return;
}
if (Nested.ReturnType != typeof(bool))
{
throw ConvertException.StaticTypeSafety(typeof(bool), Nested.ReturnType, Nested.ToString());
}
Nested.GuardTypeSafety();
}
public void StackTraceIsUsedWhenPresent()
{
Exception ex1 = new ApplicationException("test 1");
Exception ex2 = PutStackTraceOnException(new ApplicationException("test 1"));
var fingerprint1 = ConvertException.ToFingerprint(ex1);
var fingerprint2 = ConvertException.ToFingerprint(ex2);
AssertIsHash(fingerprint1);
AssertIsHash(fingerprint2);
Assert.That(fingerprint1, Is.Not.EqualTo(fingerprint2));
}
public void IdenticalMessageExceptionsHaveSameFingerprint()
{
Exception ex1 = new ApplicationException("test 1");
Exception ex2 = new ApplicationException("test 1");
var fingerprint1 = ConvertException.ToFingerprint(ex1);
var fingerprint2 = ConvertException.ToFingerprint(ex2);
AssertIsHash(fingerprint1);
AssertIsHash(fingerprint2);
Assert.That(fingerprint1, Is.EqualTo(fingerprint2));
}
public void PriceConverterTest()
{
var engine = new FileHelperEngine <GodRecord>();
ConvertException ex =
Assert.Throws <ConvertException>(
() => TestCommon.ReadTest <GodRecord>(engine, "Good", "PriceConverter.txt"));
Assert.AreEqual(1, ex.LineNumber);
Assert.AreEqual("PriceList", ex.FieldName);
Assert.AreEqual(typeof(decimal), ex.FieldType);
Assert.AreEqual(null, ex.FieldStringValue);
}
public override void GuardTypeSafety()
{
if (Lhs == null || Rhs == null || Lhs.ReturnType == null || Rhs.ReturnType == null)
{
return;
}
if (Lhs.ReturnType != Rhs.ReturnType)
{
throw ConvertException.StaticTypeSafety(Lhs.ReturnType, Rhs.ReturnType, Rhs.ToString());
}
Lhs.GuardTypeSafety();
Rhs.GuardTypeSafety();
}
public override void GuardTypeSafety()
{
if (Lhs == null || Lhs.ReturnType == null)
{
return;
}
if (Lhs.ReturnType != typeof(string))
{
throw ConvertException.StaticTypeSafety(typeof(bool), Lhs.ReturnType, Lhs.ToString());
}
Lhs.GuardTypeSafety();
if (Rhs == null || Rhs.ReturnType == null)
{
return;
}
Rhs.GuardTypeSafety();
}
public static void Extended(this ILogger logger, LogLevel logLevel, string message, object logProperties, Exception ex = null)
{
if (ex == null)
{
ExtendedWithException(logger, logLevel, message, logProperties, null, 0, 0, null);
}
else if (ex.InnerException == null)
{
ExtendedWithException(logger, logLevel, message, logProperties, ex, 1, 1, null);
}
else
{
var allExceptions = ConvertException.ToList(ex);
var tag = Guid.NewGuid().ToString();
for (var index = 0; index < allExceptions.Count; index++)
{
ExtendedWithException(logger, logLevel, message, logProperties,
allExceptions[index], index + 1, allExceptions.Count, tag);
}
}
}
public override void GuardTypeSafety()
{
if (Condition?.ReturnType == null)
{
return;
}
if (Then?.ReturnType == null)
{
return;
}
if (Else?.ReturnType == null)
{
return;
}
if (Condition.ReturnType != typeof(bool))
{
throw ConvertException.StaticTypeSafety(typeof(bool), Condition.ReturnType, Condition.ToString());
}
// if (Rhs.ReturnType != typeof(bool)) throw ConvertException.StaticTypeSafety(typeof(bool), Rhs.ReturnType, Rhs.ToString());
// Lhs.GuardTypeSafety();
// Rhs.GuardTypeSafety();
}
internal object AssignFromString(ExtractedInfo fieldString, LineInfo line)
{
object val;
switch (mTrimMode)
{
case TrimMode.None:
break;
case TrimMode.Both:
fieldString.TrimBoth(mTrimChars);
break;
case TrimMode.Left:
fieldString.TrimStart(mTrimChars);
break;
case TrimMode.Right:
fieldString.TrimEnd(mTrimChars);
break;
}
try
{
if (mConvertProvider == null)
{
if (mIsStringField)
{
val = fieldString.ExtractedString();
}
else
{
// Trim it to use Convert.ChangeType
fieldString.TrimBoth(WhitespaceChars);
if (fieldString.Length == 0)
{
// Empty stand for null
val = GetNullValue();
}
else
{
val = Convert.ChangeType(fieldString.ExtractedString(), mFieldType, null);
}
}
}
else
{
if (mConvertProvider.CustomNullHandling == false &&
fieldString.HasOnlyThisChars(WhitespaceChars))
{
val = GetNullValue();
}
else
{
var from = fieldString.ExtractedString();
val = mConvertProvider.StringToField(from);
if (val == null)
{
val = GetNullValue();
}
}
}
return(val);
}
catch (ConvertException ex)
{
var e = ConvertException.ReThrowException(ex, mFieldInfo.Name, line.mReader.LineNumber, fieldString.ExtractedFrom + 1);
throw e;
}
}
internal static ConvertException ReThrowException(ConvertException ex, string fieldName, int line, int column)
{
return new ConvertException(ex.FieldStringValue, ex.mFieldType, fieldName, line, column, ex.mMessageExtra);
}
public override void GuardTypeSafety()
{
if (_function.IsParamsFunctions())
{
for (int i = 0; i < _nested.Nodes.Count; i++)
{
var argumentType = i < _function.Arguments.Length?_function.Arguments[i].Type:_function.Arguments.Last().Type;
Expression node = _nested.Nodes[i];
if (node == null || node.ReturnType == null ||
typeof(object).Equals(argumentType))
{
continue;
}
if (_function.Arguments[i].Type.IsInterface)
{
if (!node.ReturnType.GetInterfaces().Contains(argumentType))
{
throw ConvertException.StaticTypeSafety(argumentType, node.ReturnType,
node.ToString());
}
}
else
{
if (node.ReturnType != _function.Arguments[i].Type)
{
throw ConvertException.StaticTypeSafety(argumentType, node.ReturnType,
node.ToString());
}
}
node.GuardTypeSafety();
}
}
else
{
for (int i = 0; i < _function.Arguments.Length; i++)
{
Expression node = _nested.Nodes[i];
if (node == null || node.ReturnType == null ||
typeof(object).Equals(_function.Arguments[i].Type))
{
continue;
}
if (_function.Arguments[i].Type.IsInterface)
{
if (!node.ReturnType.GetInterfaces().Contains(_function.Arguments[i].Type))
{
throw ConvertException.StaticTypeSafety(_function.Arguments[i].Type, node.ReturnType,
node.ToString());
}
}
else if ((_function.Arguments[i].Type != typeof(object) && !node.ReturnType.IsArray && !_function.Arguments[i].Type.IsArray) ||
(_function.Arguments[i].Type != typeof(object[]) && node.ReturnType.IsArray && _function.Arguments[i].Type.IsArray)
)
{
if (node.ReturnType != _function.Arguments[i].Type)
{
throw ConvertException.StaticTypeSafety(_function.Arguments[i].Type, node.ReturnType,
node.ToString());
}
}
node.GuardTypeSafety();
}
}
}
