public void reading_and_writing_CKExceptionData_with_BinaryWriter_and_BinaryReader()
{
var dataE0 = CKExceptionData.CreateFrom(ThrowAggregatedException());
var dataE1 = CKExceptionData.CreateFrom(ThrowSimpleException("Test Message"));
var dataE2 = CKExceptionData.CreateFrom(ThrowLoaderException());
var dataE3 = CKExceptionData.CreateFrom(ThrowExceptionWithInner());
var dataE4 = CKExceptionData.CreateFrom(ThrowTwoInnerExceptions());
using (var mem = new MemoryStream())
{
CKBinaryWriter w = new CKBinaryWriter(mem);
dataE0.Write(w);
dataE1.Write(w);
dataE2.Write(w);
dataE3.Write(w);
dataE4.Write(w);
mem.Position = 0;
var r = new CKBinaryReader(mem);
var data0 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data0.ToString().Should().Be(dataE0.ToString());
var data1 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data1.ToString().Should().Be(dataE1.ToString());
var data2 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data2.ToString().Should().Be(dataE2.ToString());
var data3 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data3.ToString().Should().Be(dataE3.ToString());
var data4 = new CKExceptionData(r, StringAndStringBuilderExtension.IsCRLF);
data4.ToString().Should().Be(dataE4.ToString());
}
}
private static void CheckSimpleExceptionData(CKExceptionData simpleData, Func <string, bool> message, bool?hasInner = null, bool hasStack = true)
{
message(simpleData.Message).Should().BeTrue("Invalid message.");
simpleData.ExceptionTypeName.Should().Be("Exception");
simpleData.ExceptionTypeAssemblyQualifiedName.Should().Be(typeof(Exception).AssemblyQualifiedName);
if (hasStack)
{
simpleData.StackTrace.Should().NotBeNull("Stack trace is not null when the exception has actually been thrown.");
}
else
{
simpleData.StackTrace.Should().BeNull();
}
if (hasInner.HasValue)
{
if (hasInner.Value)
{
simpleData.InnerException.Should().NotBeNull();
}
else
{
simpleData.InnerException.Should().BeNull();
}
}
simpleData.AggregatedExceptions.Should().BeNull();
simpleData.LoaderExceptions.Should().BeNull();
}
private static void CheckSimpleExceptionData(CKExceptionData simpleData, Func <string, bool> message, bool?hasInner = null, bool hasStack = true)
{
Assert.That(message(simpleData.Message), "Invalid message.");
Assert.That(simpleData.ExceptionTypeName, Is.EqualTo("Exception"));
Assert.That(simpleData.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(typeof(Exception).AssemblyQualifiedName));
if (hasStack)
{
Assert.That(simpleData.StackTrace, Is.Not.Null, "Stack trace is not null when the exception has actually been thrown.");
}
else
{
Assert.That(simpleData.StackTrace, Is.Null);
}
if (hasInner.HasValue)
{
if (hasInner.Value)
{
Assert.That(simpleData.InnerException, Is.Not.Null);
}
else
{
Assert.That(simpleData.InnerException, Is.Null);
}
}
Assert.That(simpleData.AggregatedExceptions, Is.Null);
Assert.That(simpleData.LoaderExceptions, Is.Null);
}
public void reading_and_writing_CKExceptionData_with_Standard_Serialization()
{
var dataE0 = CKExceptionData.CreateFrom(ThrowAggregatedException());
var dataE1 = CKExceptionData.CreateFrom(ThrowSimpleException("Test Message"));
var dataE2 = CKExceptionData.CreateFrom(ThrowLoaderException());
var dataE3 = CKExceptionData.CreateFrom(ThrowExceptionWithInner());
var dataE4 = CKExceptionData.CreateFrom(ThrowTwoInnerExceptions());
BinaryFormatter f = new BinaryFormatter();
using (var mem = new MemoryStream())
{
f.Serialize(mem, dataE0);
f.Serialize(mem, dataE1);
f.Serialize(mem, dataE2);
f.Serialize(mem, dataE3);
f.Serialize(mem, dataE4);
mem.Position = 0;
var data0 = (CKExceptionData)f.Deserialize(mem);
data0.ToString().Should().Be(dataE0.ToString());
var data1 = (CKExceptionData)f.Deserialize(mem);
data1.ToString().Should().Be(dataE1.ToString());
var data2 = (CKExceptionData)f.Deserialize(mem);
data2.ToString().Should().Be(dataE2.ToString());
var data3 = (CKExceptionData)f.Deserialize(mem);
data3.ToString().Should().Be(dataE3.ToString());
var data4 = (CKExceptionData)f.Deserialize(mem);
data4.ToString().Should().Be(dataE4.ToString());
}
}
public void FromSimplestException()
{
CheckSimpleExceptionData(CKExceptionData.CreateFrom(new Exception("")), s => s == "", false, false);
var simpleData = CKExceptionData.CreateFrom(ThrowSimpleException("Test"));
CheckSimpleExceptionData(simpleData, s => s == "Test", false, true);
}
public void WithInnerExceptions()
{
Exception e = ThrowExceptionWithInner();
var d = CKExceptionData.CreateFrom(e);
CheckSimpleExceptionData(d, s => s == "Outer", true);
CheckSimpleExceptionData(d.InnerException, s => s == "Inner", false);
}
public LEOpenGroup(LEMCOpenGroup e)
{
_text = e.Text;
_time = e.LogTime;
_fileName = e.FileName;
_lineNumber = e.LineNumber;
_level = e.LogLevel;
_tags = e.Tags;
_ex = e.Exception;
}
public LEOpenGroup(string text, DateTimeStamp t, string fileName, int lineNumber, LogLevel l, CKTrait tags, CKExceptionData ex)
{
_text = text;
_time = t;
_fileName = fileName;
_lineNumber = lineNumber;
_level = l;
_tags = tags;
_ex = ex;
}
public void LogEntry_write_and_read_back()
{
var exInner = new CKExceptionData("message", "typeof(exception)", "assemblyQualifiedName", "stackTrace", null, "fileName", "fusionLog", null, null);
var ex2 = new CKExceptionData("message2", "typeof(exception2)", "assemblyQualifiedName2", "stackTrace2", exInner, "fileName2", "fusionLog2", null, null);
var exL = new CKExceptionData("loader-message", "typeof(loader-exception)", "loader-assemblyQualifiedName", "loader-stackTrace", null, "loader-fileName", "loader-fusionLog", null, null);
var exAgg = new CKExceptionData("agg-message", "typeof(agg-exception)", "agg-assemblyQualifiedName", "agg-stackTrace", ex2, "fileName", "fusionLog", null, new[] { ex2, exL });
var prevLog = DateTimeStamp.UtcNow;
ILogEntry e1 = LogEntry.CreateLog("Text1", new DateTimeStamp(DateTime.UtcNow, 42), LogLevel.Info, "c:\\test.cs", 3712, ActivityMonitor.Tags.CreateDependentToken, exAgg);
ILogEntry e2 = LogEntry.CreateMulticastLog("GOId", "3712", LogEntryType.Line, prevLog, 5, "Text2", DateTimeStamp.UtcNow, LogLevel.Fatal, null, 3712, ActivityMonitor.Tags.CreateDependentToken, exAgg);;
using (var mem = new MemoryStream())
using (var w = new CKBinaryWriter(mem))
{
w.Write(LogReader.CurrentStreamVersion);
e1.WriteLogEntry(w);
e2.WriteLogEntry(w);
w.Write((byte)0);
w.Flush();
byte[] versionBytes = new byte[4];
mem.Position = 0;
mem.Read(versionBytes, 0, 4);
BitConverter.ToInt32(versionBytes, 0).Should().Be(LogReader.CurrentStreamVersion);
using (var reader = new LogReader(mem, LogReader.CurrentStreamVersion, 4))
{
reader.MoveNext().Should().BeTrue();
reader.Current.Text.Should().Be(e1.Text);
reader.Current.LogLevel.Should().Be(e1.LogLevel);
reader.Current.LogTime.Should().Be(e1.LogTime);
reader.Current.FileName.Should().Be(e1.FileName);
reader.Current.LineNumber.Should().Be(e1.LineNumber);
reader.Current.Exception.ExceptionTypeAssemblyQualifiedName.Should().Be(e1.Exception.ExceptionTypeAssemblyQualifiedName);
reader.Current.Exception.ToString().Should().Be(e1.Exception.ToString());
reader.MoveNext().Should().BeTrue();
reader.CurrentMulticast.GrandOutputId.Should().Be("GOId");
reader.CurrentMulticast.MonitorId.Should().Be("3712");
reader.CurrentMulticast.PreviousEntryType.Should().Be(LogEntryType.Line);
reader.CurrentMulticast.PreviousLogTime.Should().Be(prevLog);
reader.Current.Text.Should().Be(e2.Text);
reader.Current.LogTime.Should().Be(e2.LogTime);
reader.Current.FileName.Should().BeNull();
reader.Current.LineNumber.Should().Be(0, "Since no file name is set, line number is 0.");
reader.Current.Exception.ExceptionTypeAssemblyQualifiedName.Should().Be(e2.Exception.ExceptionTypeAssemblyQualifiedName);
reader.Current.Exception.ToString().Should().Be(e2.Exception.ToString());
reader.MoveNext().Should().BeFalse();
reader.BadEndOfFileMarker.Should().BeFalse();
}
}
}
public void LogEntryReadWrite()
{
var exInner = new CKExceptionData("message", "typeof(exception)", "assemblyQualifiedName", "stackTrace", null, "fileName", "fusionLog", null, null);
var ex2 = new CKExceptionData("message2", "typeof(exception2)", "assemblyQualifiedName2", "stackTrace2", exInner, "fileName2", "fusionLog2", null, null);
var exL = new CKExceptionData("loader-message", "typeof(loader-exception)", "loader-assemblyQualifiedName", "loader-stackTrace", null, "loader-fileName", "loader-fusionLog", null, null);
var exAgg = new CKExceptionData("agg-message", "typeof(agg-exception)", "agg-assemblyQualifiedName", "agg-stackTrace", ex2, "fileName", "fusionLog", null, new[] { ex2, exL });
var prevLog = DateTimeStamp.UtcNow;
ILogEntry e1 = LogEntry.CreateLog("Text1", new DateTimeStamp(DateTime.UtcNow, 42), LogLevel.Info, "c:\\test.cs", 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg);
ILogEntry e2 = LogEntry.CreateMulticastLog(Guid.Empty, LogEntryType.Line, prevLog, 5, "Text2", DateTimeStamp.UtcNow, LogLevel.Fatal, null, 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg);
using (var mem = new MemoryStream())
using (var w = new CKBinaryWriter(mem))
{
w.Write(LogReader.CurrentStreamVersion);
e1.WriteLogEntry(w);
e2.WriteLogEntry(w);
w.Write((byte)0);
w.Flush();
byte[] versionBytes = new byte[4];
mem.Position = 0;
mem.Read(versionBytes, 0, 4);
Assert.That(BitConverter.ToInt32(versionBytes, 0), Is.EqualTo(LogReader.CurrentStreamVersion));
using (var reader = new LogReader(mem, LogReader.CurrentStreamVersion, 4))
{
Assert.That(reader.MoveNext());
Assert.That(reader.Current.Text, Is.EqualTo(e1.Text));
Assert.That(reader.Current.LogLevel, Is.EqualTo(e1.LogLevel));
Assert.That(reader.Current.LogTime, Is.EqualTo(e1.LogTime));
Assert.That(reader.Current.FileName, Is.EqualTo(e1.FileName));
Assert.That(reader.Current.LineNumber, Is.EqualTo(e1.LineNumber));
Assert.That(reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(e1.Exception.ExceptionTypeAssemblyQualifiedName));
Assert.That(reader.Current.Exception.ToString(), Is.EqualTo(e1.Exception.ToString()));
Assert.That(reader.MoveNext());
Assert.That(reader.CurrentMulticast.PreviousEntryType, Is.EqualTo(LogEntryType.Line));
Assert.That(reader.CurrentMulticast.PreviousLogTime, Is.EqualTo(prevLog));
Assert.That(reader.Current.Text, Is.EqualTo(e2.Text));
Assert.That(reader.Current.LogTime, Is.EqualTo(e2.LogTime));
Assert.That(reader.Current.FileName, Is.Null);
Assert.That(reader.Current.LineNumber, Is.EqualTo(0), "Since no file name is set, line number is 0.");
Assert.That(reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(e2.Exception.ExceptionTypeAssemblyQualifiedName));
Assert.That(reader.Current.Exception.ToString(), Is.EqualTo(e2.Exception.ToString()));
Assert.That(reader.MoveNext(), Is.False);
Assert.That(reader.BadEndOfFileMarker, Is.False);
}
}
}
public void AggregatedExceptions()
{
AggregateException eAgg = ThrowAggregatedException();
var d = CKExceptionData.CreateFrom(eAgg);
d.ExceptionTypeAssemblyQualifiedName.Should().Be(typeof(AggregateException).AssemblyQualifiedName);
d.ExceptionTypeName.Should().Be(typeof(AggregateException).Name);
d.AggregatedExceptions.Count.Should().BeGreaterOrEqualTo(1);
d.InnerException.Should().BeSameAs(d.AggregatedExceptions[0]);
for (int i = 0; i < d.AggregatedExceptions.Count; ++i)
{
CheckSimpleExceptionData(d.AggregatedExceptions[i], s => s.StartsWith("Ex n°"));
}
}
public void AggregatedExceptions()
{
AggregateException eAgg = ThrowAggregatedException();
var d = CKExceptionData.CreateFrom(eAgg);
Assert.That(d.ExceptionTypeAssemblyQualifiedName, Is.EqualTo(typeof(AggregateException).AssemblyQualifiedName));
Assert.That(d.ExceptionTypeName, Is.EqualTo(typeof(AggregateException).Name));
Assert.That(d.AggregatedExceptions.Count, Is.GreaterThanOrEqualTo(1));
Assert.That(d.InnerException, Is.SameAs(d.AggregatedExceptions[0]));
for (int i = 0; i < d.AggregatedExceptions.Count; ++i)
{
CheckSimpleExceptionData(d.AggregatedExceptions[i], s => s.StartsWith("Ex n°"));
}
}
static void DumpSampleLogs2(Random r, GrandOutput g)
{
var m = new ActivityMonitor(false);
g.EnsureGrandOutputClient(m);
m.Fatal("An error occured", _exceptionWithInner);
m.Fatal("Same error occured (wrapped in CKException)", new CKException(CKExceptionData.CreateFrom(_exceptionWithInner)));
m.SetTopic("This is a topic...");
m.Trace("a trace");
m.Trace("another one");
m.SetTopic("Please, show this topic!");
m.Trace("Anotther trace.");
using (m.OpenTrace("A group trace."))
{
m.Trace("A trace in group.");
m.Info("An info...");
using (m.OpenInfo(@"A group information... with a
multi
-line
message.
This MUST be correctly indented!"))
{
m.Info("Info in info group.");
m.Info("Another info in info group.");
m.Error("An error.", _exceptionWithInnerLoader);
m.Error("Same error occured (wrapped in CKException)", new CKException(CKExceptionData.CreateFrom(_exceptionWithInnerLoader)));
m.Warn("A warning.");
m.Trace("Something must be said.");
m.CloseGroup("Everything is in place.");
}
}
m.SetTopic(null);
using (m.OpenTrace("A group with multiple conclusions."))
{
using (m.OpenTrace("A group with no conclusion."))
{
m.Trace("Something must be said.");
}
m.CloseGroup(new[] {
new ActivityLogGroupConclusion("My very first conclusion."),
new ActivityLogGroupConclusion("My second conclusion."),
new ActivityLogGroupConclusion(@"My very last conclusion
is a multi line one.
and this is fine!")
});
}
m.Trace("This is the final trace.");
}
private Document GetDocument(CKExceptionData exception)
{
var document = new Document();
foreach (var propertyInfo in exception.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
var exceptionValue = exception.GetType().GetProperty(propertyInfo.Name)?.GetValue(exception);
if (exceptionValue == null)
{
continue;
}
switch (propertyInfo.Name)
{
case LogField.AGGREGATED_EXCEPTIONS:
if (_exceptionDepth == 0)
{
var exList = new StringBuilder();
foreach (var ex in exception.AggregatedExceptions)
{
exList.Append(GetDocument(ex).Get(LogField.INDEX_DTS));
exList.Append(";");
_exceptionDepth++;
}
document.Add(new Int32Field(LogField.EXCEPTION_DEPTH, _exceptionDepth, Field.Store.YES));
document.Add(new TextField(LogField.AGGREGATED_EXCEPTIONS, exList.ToString(), Field.Store.YES));
_exceptionDepth = 0;
}
break;
case LogField.INNER_EXCEPTION:
document.Add(new StringField(LogField.INNER_EXCEPTION, GetDocument(exceptionValue as CKExceptionData).Get("IndexDTS"), Field.Store.YES));
break;
default:
document.Add(new TextField(propertyInfo.Name, exceptionValue.ToString(), Field.Store.YES));
break;
}
}
document.Add(new StringField(LogField.INDEX_DTS, CreateIndexDts().ToString(), Field.Store.YES));
WriteDocument(document);
return(document);
}
private static void CheckSimpleExceptionData( CKExceptionData simpleData, Func<string,bool> message, bool? hasInner = null, bool hasStack = true )
{
Assert.That( message(simpleData.Message), "Invalid message." );
Assert.That( simpleData.ExceptionTypeName, Is.EqualTo( "Exception" ) );
Assert.That( simpleData.ExceptionTypeAssemblyQualifiedName, Is.EqualTo( typeof( Exception ).AssemblyQualifiedName ) );
if( hasStack )
Assert.That( simpleData.StackTrace, Is.Not.Null, "Stack trace is not null when the exception has actually been thrown." );
else Assert.That( simpleData.StackTrace, Is.Null );
if( hasInner.HasValue )
{
if( hasInner.Value ) Assert.That( simpleData.InnerException, Is.Not.Null );
else Assert.That( simpleData.InnerException, Is.Null );
}
Assert.That( simpleData.AggregatedExceptions, Is.Null );
Assert.That( simpleData.LoaderExceptions, Is.Null );
}
static void DoWriteLog(CKBinaryWriter w, StreamLogType t, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber)
{
if (tags != null && !tags.IsEmpty)
{
t |= StreamLogType.HasTags;
}
if (ex != null)
{
t |= StreamLogType.HasException;
if (text == ex.Message)
{
t |= StreamLogType.IsTextTheExceptionMessage;
}
}
if (fileName != null)
{
t |= StreamLogType.HasFileName;
}
if (logTime.Uniquifier != 0)
{
t |= StreamLogType.HasUniquifier;
}
WriteLogTypeAndLevel(w, t, level);
w.Write(logTime.TimeUtc.ToBinary());
if (logTime.Uniquifier != 0)
{
w.Write(logTime.Uniquifier);
}
if ((t & StreamLogType.HasTags) != 0)
{
w.Write(tags.ToString());
}
if ((t & StreamLogType.HasFileName) != 0)
{
w.Write(fileName);
w.WriteNonNegativeSmallInt32(lineNumber);
}
if ((t & StreamLogType.HasException) != 0)
{
ex.Write(w);
}
if ((t & StreamLogType.IsTextTheExceptionMessage) == 0)
{
w.Write(text);
}
}
/// <summary>
/// Creates a <see cref="ILogEntry"/> for a line.
/// </summary>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the line (number of opened groups above).</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="t">Time stamp of the log entry.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <returns>A log entry object.</returns>
public static IMulticastLogEntry CreateMulticastLog(Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, string text, DateTimeStamp t, LogLevel level, string fileName, int lineNumber, CKTrait tags, CKExceptionData ex)
{
return(new LEMCLog(monitorId, depth, previousLogTime, previousEntryType, text, t, fileName, lineNumber, level, tags, ex));
}
/// <summary>
/// Reads a <see cref="ILogEntry"/> from the binary reader that can be a <see cref="IMulticastLogEntry"/>.
/// If the first read byte is 0, read stops and null is returned.
/// The 0 byte is the "end marker" that <see cref="CKMonWriterClient.Close()"/> write, but this
/// method can read non zero-terminated streams (it catches an EndOfStreamException when reading the first byte and handles it silently).
/// This method can throw any type of exception except <see cref="EndOfStreamException"/>
/// (like <see cref="InvalidDataException"/> for instance) that must be handled by the caller.
/// </summary>
/// <param name="r">The binary reader.</param>
/// <param name="streamVersion">The version of the stream.</param>
/// <param name="badEndOfFile">True whenever the end of file is the result of an <see cref="EndOfStreamException"/>.</param>
/// <returns>The log entry or null if a zero byte (end marker) has been found.</returns>
static public ILogEntry?Read(CKBinaryReader r, int streamVersion, out bool badEndOfFile)
{
Throw.CheckNotNullArgument(r);
badEndOfFile = false;
StreamLogType t = StreamLogType.EndOfStream;
LogLevel logLevel = LogLevel.None;
try
{
ReadLogTypeAndLevel(r, streamVersion, out t, out logLevel);
}
catch (EndOfStreamException)
{
badEndOfFile = true;
// Silently ignores here reading beyond the stream: this
// kindly handles the lack of terminating 0 byte.
}
if (t == StreamLogType.EndOfStream)
{
return(null);
}
if ((t & StreamLogType.TypeMask) == StreamLogType.TypeGroupClosed)
{
return(ReadGroupClosed(streamVersion, r, t, logLevel));
}
DateTimeStamp time = new DateTimeStamp(DateTime.FromBinary(r.ReadInt64()), (t & StreamLogType.HasUniquifier) != 0 ? r.ReadByte() : (Byte)0);
if (time.TimeUtc.Year < 2014 || time.TimeUtc.Year > 3000)
{
throw new InvalidDataException("Date year before 2014 or after 3000 are considered invalid.");
}
CKTrait tags = ActivityMonitor.Tags.Empty;
string? fileName = null;
int lineNumber = 0;
CKExceptionData?ex = null;
string? text = null;
if ((t & StreamLogType.HasTags) != 0)
{
tags = ActivityMonitor.Tags.Register(r.ReadString());
}
if ((t & StreamLogType.HasFileName) != 0)
{
fileName = r.ReadString();
lineNumber = streamVersion < 6 ? r.ReadInt32() : r.ReadNonNegativeSmallInt32();
if (lineNumber > 100 * 1000)
{
throw new InvalidDataException("LineNumber greater than 100K is considered invalid.");
}
}
if ((t & StreamLogType.HasException) != 0)
{
ex = new CKExceptionData(r);
if ((t & StreamLogType.IsTextTheExceptionMessage) != 0)
{
text = ex.Message;
}
}
if (text == null)
{
text = r.ReadString((t & StreamLogType.IsLFOnly) == 0);
}
string gId;
string mId;
int depth;
LogEntryType prevType;
DateTimeStamp prevTime;
if ((t & StreamLogType.TypeMask) == StreamLogType.TypeLine)
{
if ((t & StreamLogType.IsMultiCast) == 0)
{
return(new LELog(text, time, fileName, lineNumber, logLevel, tags, ex));
}
ReadMulticastFooter(streamVersion, r, t, out gId, out mId, out depth, out prevType, out prevTime);
return(new LEMCLog(gId, mId, depth, prevTime, prevType, text, time, fileName, lineNumber, logLevel, tags, ex));
}
if ((t & StreamLogType.TypeMask) != StreamLogType.TypeOpenGroup)
{
throw new InvalidDataException();
}
if ((t & StreamLogType.IsMultiCast) == 0)
{
return(new LEOpenGroup(text, time, fileName, lineNumber, logLevel, tags, ex));
}
ReadMulticastFooter(streamVersion, r, t, out gId, out mId, out depth, out prevType, out prevTime);
return(new LEMCOpenGroup(gId, mId, depth, prevTime, prevType, text, time, fileName, lineNumber, logLevel, tags, ex));
}
/// <summary>
/// Binary writes a log entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="logTime">Time stamp of the log entry.</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
static public void WriteLog(CKBinaryWriter w, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
DoWriteLog(w, isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine, level, logTime, text, tags, ex, fileName, lineNumber);
}
public void reading_and_writing_CKExceptionData_with_BinaryWriter_and_BinaryReader()
{
var dataE0 = CKExceptionData.CreateFrom( ThrowAggregatedException() );
var dataE1 = CKExceptionData.CreateFrom( ThrowSimpleException( "Test Message" ) );
var dataE2 = CKExceptionData.CreateFrom( ThrowLoaderException() );
var dataE3 = CKExceptionData.CreateFrom( ThrowExceptionWithInner() );
var dataE4 = CKExceptionData.CreateFrom( ThrowTwoInnerExceptions() );
using( var mem = new MemoryStream() )
{
CKBinaryWriter w = new CKBinaryWriter( mem );
dataE0.Write( w );
dataE1.Write( w );
dataE2.Write( w );
dataE3.Write( w );
dataE4.Write( w );
mem.Position = 0;
var r = new CKBinaryReader( mem );
var data0 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data0.ToString(), dataE0.ToString() );
var data1 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data1.ToString(), dataE1.ToString() );
var data2 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data2.ToString(), dataE2.ToString() );
var data3 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data3.ToString(), dataE3.ToString() );
var data4 = new CKExceptionData( r, StringAndStringBuilderExtension.IsCRLF );
Assert.AreEqual( data4.ToString(), dataE4.ToString() );
}
}
/// <summary>
/// Creates a <see cref="ILogEntry"/> for an opened group.
/// </summary>
/// <param name="text">Text of the log entry.</param>
/// <param name="t">Time stamp of the log entry.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <returns>A log entry object.</returns>
public static ILogEntry CreateOpenGroup(string text, DateTimeStamp t, LogLevel level, string fileName, int lineNumber, CKTrait tags, CKExceptionData ex)
{
return(new LEOpenGroup(text, t, fileName, lineNumber, level, tags, ex));
}
public LEMCOpenGroup(Guid monitorId, int depth, DateTimeStamp previousLogTime, LogEntryType previousEntryType, string text, DateTimeStamp t, string fileName, int lineNumber, LogLevel l, CKTrait tags, CKExceptionData ex)
: base(text, t, fileName, lineNumber, l, tags, ex)
{
_monitorId = monitorId;
_depth = depth;
_previousEntryType = previousEntryType;
_previousLogTime = previousLogTime;
}
/// <summary>
/// Binary writes a multicast log entry.
/// </summary>
/// <param name="w">Binary writer to use.</param>
/// <param name="monitorId">Identifier of the monitor.</param>
/// <param name="previousEntryType">Log type of the previous entry in the monitor..</param>
/// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param>
/// <param name="depth">Depth of the line (number of opened groups above).</param>
/// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param>
/// <param name="text">Text of the log entry.</param>
/// <param name="level">Log level of the log entry.</param>
/// <param name="logTime">Time stamp of the log entry.</param>
/// <param name="tags">Tags of the log entry</param>
/// <param name="ex">Exception of the log entry.</param>
/// <param name="fileName">Source file name of the log entry</param>
/// <param name="lineNumber">Source line number of the log entry</param>
static public void WriteLog(CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber)
{
if (w == null)
{
throw new ArgumentNullException("w");
}
StreamLogType type = StreamLogType.IsMultiCast | (isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine);
type = UpdateTypeWithPrevious(type, previousEntryType, ref previousLogTime);
DoWriteLog(w, type, level, logTime, text, tags, ex, fileName, lineNumber);
WriteMulticastFooter(w, monitorId, previousEntryType, previousLogTime, depth);
}
