/// <summary>
/// Creates a logger for the markup stream writer.
/// </summary>
/// <param name="writer">The markup stream writer.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
public MarkupStreamLogger(MarkupStreamWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
this.writer = writer;
}
private void WritePreambleTo(MarkupStreamWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
foreach (Attachment attachment in attachments)
{
writer.Container.Attach(attachment);
}
}
/// <summary>
/// Writes the contents of the stream to a markup stream writer.
/// </summary>
/// <param name="writer">The writer.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
public void WriteTo(MarkupStreamWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
if (body != null)
{
body.WriteTo(writer);
}
}
/// <summary>
/// Writes the structured text to a markup stream writer and truncates its text
/// to a particular maximum length, omitting all subsequent contents.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="maxLength">The maximum length of text to write.</param>
/// <returns>True if truncation occurred.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="maxLength"/> is negative.</exception>
public bool TruncatedWriteTo(MarkupStreamWriter writer, int maxLength)
{
if (maxLength < 0)
{
throw new ArgumentOutOfRangeException("maxLength", "Max length must not be negative.");
}
WritePreambleTo(writer);
TruncateTextVisitor visitor = new TruncateTextVisitor(writer, maxLength);
bodyTag.Accept(visitor);
return(visitor.Truncating);
}
private static void WriteContext(MarkupStreamWriter writer, Substring context, int maxContextLength)
{
if (context.Length < maxContextLength)
{
writer.Write(context.ToString());
}
else
{
int split = maxContextLength / 2;
if (split > 0)
{
writer.Write(context.Extract(0, split).ToString());
writer.WriteEllipsis();
writer.Write(context.Extract(context.Length - split));
}
}
}
/// <summary>
/// Writes the diffs using the specified
/// presentation style and no limits on the context length.
/// </summary>
/// <remarks>
/// <para>
/// Changes are annotated by markers: <see cref="Marker.DiffAddition" />, <see cref="Marker.DiffDeletion" />
/// and <see cref="Marker.DiffChange" />.
/// </para>
/// <para>
/// If the style is <see cref="DiffStyle.Interleaved" /> then the left document
/// is considered the original and the right document is the considered to be the
/// one that was modified so deletions appear within the left and additions within the right.
/// </para>
/// <para>
/// If the style is <see cref="DiffStyle.LeftOnly" /> or <see cref="DiffStyle.RightOnly" />
/// then only the deletion and changed markers are used.
/// </para>
/// </remarks>
/// <param name="writer">The test log stream writer to receive the highlighted document.</param>
/// <param name="style">The presentation style.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref nameref="writer" /> if null.</exception>
public void WriteTo(MarkupStreamWriter writer, DiffStyle style)
{
WriteTo(writer, style, int.MaxValue);
}
/// <summary>
/// Writes the diffs using the specified presentation style and max context length.
/// </summary>
/// <remarks>
/// <para>
/// Changes are annotated by markers: <see cref="Marker.DiffAddition" />, <see cref="Marker.DiffDeletion" />
/// and <see cref="Marker.DiffChange" />.
/// </para>
/// <para>
/// If the style is <see cref="DiffStyle.Interleaved" /> then the left document
/// is considered the original and the right document is the considered to be the
/// one that was modified so deletions appear within the left and additions within the right.
/// </para>
/// <para>
/// If the style is <see cref="DiffStyle.LeftOnly" /> or <see cref="DiffStyle.RightOnly" />
/// then only the deletion and changed markers are used.
/// </para>
/// </remarks>
/// <param name="writer">The test log stream writer to receive the highlighted document.</param>
/// <param name="style">The presentation style.</param>
/// <param name="maxContextLength">The maximum number of characters of unchanged regions
/// to display for context, or <see cref="int.MaxValue" /> for no limit. Extraneous context
/// is split in two with an ellipsis inserted in between both halves.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref nameref="writer" /> if null.</exception>
/// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="maxContextLength"/>
/// is negative.</exception>
public void WriteTo(MarkupStreamWriter writer, DiffStyle style, int maxContextLength)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (maxContextLength < 0)
throw new ArgumentOutOfRangeException("maxContextLength");
foreach (Diff diff in diffs)
{
if (diff.Kind == DiffKind.NoChange)
{
WriteContext(writer, new Substring(leftDocument, diff.LeftRange), maxContextLength);
}
else
{
if (diff.LeftRange.Length != 0)
{
switch (style)
{
case DiffStyle.Interleaved:
using (writer.BeginMarker(Marker.DiffDeletion))
writer.Write(diff.LeftRange.SubstringOf(leftDocument));
break;
case DiffStyle.LeftOnly:
using (writer.BeginMarker(diff.RightRange.Length == 0 ? Marker.DiffDeletion : Marker.DiffChange))
writer.Write(diff.LeftRange.SubstringOf(leftDocument));
break;
}
}
if (diff.RightRange.Length != 0)
{
switch (style)
{
case DiffStyle.Interleaved:
using (writer.BeginMarker(Marker.DiffAddition))
writer.Write(diff.RightRange.SubstringOf(rightDocument));
break;
case DiffStyle.RightOnly:
using (writer.BeginMarker(diff.LeftRange.Length == 0 ? Marker.DiffDeletion : Marker.DiffChange))
writer.Write(diff.RightRange.SubstringOf(rightDocument));
break;
}
}
}
}
}
public TruncateTextVisitor(MarkupStreamWriter writer, int maxLength)
{
this.writer = writer;
this.maxLength = maxLength;
}
/// <summary>
/// Writes the diffs using the <see cref="DiffStyle.Interleaved" />
/// presentation style and no limits on the context length.
/// </summary>
/// <remarks>
/// <para>
/// For the purposes of determining additions and deletions, the left document
/// is considered the original and the right document is the considered to be the
/// one that was modified. Changes are annotated by markers:
/// by <see cref="Marker.DiffAddition" />, <see cref="Marker.DiffDeletion" />
/// and <see cref="Marker.DiffChange" />.
/// </para>
/// </remarks>
/// <param name="writer">The test log stream writer to receive the highlighted document.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref nameref="writer" /> if null.</exception>
public void WriteTo(MarkupStreamWriter writer)
{
WriteTo(writer, DiffStyle.Interleaved, int.MaxValue);
}
/// <inheritdoc />
public void WriteTo(MarkupStreamWriter writer)
{
ToStructuredText().WriteTo(writer);
}
/// <summary>
/// Writes the assertion failure to a test log stream.
/// </summary>
/// <param name="writer">The test log stream.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
public virtual void WriteTo(MarkupStreamWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
using (writer.BeginMarker(Marker.AssertionFailure))
{
using (writer.BeginSection(description))
{
WriteDetails(writer);
foreach (AssertionFailure innerFailure in innerFailures)
innerFailure.WriteTo(writer);
}
}
}
private static void ConfigureProcessTaskForLogging(ProcessTask task, MarkupStreamWriter writer)
{
task.Started += delegate
{
writer.BeginSection(String.Format("Run Process: {0} {1}", task.ExecutablePath, task.Arguments));
writer.WriteLine("Working Directory: {0}", task.WorkingDirectory);
writer.BeginMarker(Marker.Monospace);
};
task.ConsoleOutputDataReceived += delegate(object sender, DataReceivedEventArgs e)
{
if (e.Data != null)
writer.WriteLine(e.Data);
};
task.ConsoleErrorDataReceived += delegate(object sender, DataReceivedEventArgs e)
{
if (e.Data != null)
writer.WriteLine(e.Data);
};
task.Aborted += delegate
{
if (task.IsRunning)
writer.BeginSection("Abort requested. Killing the process!").Dispose();
};
task.Terminated += delegate
{
writer.End();
writer.WriteLine("Exit Code: {0}", task.ExitCode);
writer.End();
};
}
public RegionCookie(MarkupStreamWriter writer)
{
this.writer = writer;
}
/// <summary>
/// Writes the details about the assertion failure to the structured text writer.
/// </summary>
/// <param name="writer">The structured text writer, not null.</param>
protected virtual void WriteDetails(MarkupStreamWriter writer)
{
if (!string.IsNullOrEmpty(message))
writer.WriteLine(message);
if (labeledValues.Count != 0)
{
writer.WriteLine();
using (writer.BeginMarker(Marker.Monospace))
{
int paddedLength = ComputePaddedLabelLength();
foreach (LabeledValue labeledValue in labeledValues)
{
WriteLabel(writer, labeledValue.Label, paddedLength);
WriteFormattedValue(writer, labeledValue.FormattedValue);
writer.WriteLine();
}
}
}
if (exceptions.Count != 0)
{
foreach (ExceptionData exception in exceptions)
{
writer.WriteLine();
writer.WriteException(exception);
writer.WriteLine();
}
}
if (stackTrace != null && !stackTrace.IsEmpty)
{
writer.WriteLine();
stackTrace.WriteTo(writer);
writer.WriteLine();
}
}
public override void WriteTo(MarkupStreamWriter writer)
{
wasWriteToCalled = true;
base.WriteTo(writer);
}
private static void WriteTruncated(MarkupStreamWriter writer, StructuredText text, int maxLength)
{
if (text.TruncatedWriteTo(writer, maxLength))
writer.WriteEllipsis();
}
private static void WriteLabel(MarkupStreamWriter writer, string label, int paddedLength)
{
using (writer.BeginMarker(Marker.Label))
{
WriteTruncated(writer, new StructuredText(label), MaxLabelLengthBeforeTruncation);
WritePaddingSpaces(writer, paddedLength - label.Length);
writer.Write(@" : ");
}
}
private static void WriteFormattedValue(MarkupStreamWriter writer, StructuredText formattedValue)
{
WriteTruncated(writer, formattedValue, MaxFormattedValueLength);
}
/// <inheritdoc />
public void WriteTo(MarkupStreamWriter writer)
{
ToStructuredText().WriteTo(writer);
}
/// <summary>
/// Writes the structured text to a markup stream writer.
/// </summary>
/// <param name="writer">The writer.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
public void WriteTo(MarkupStreamWriter writer)
{
WritePreambleTo(writer);
bodyTag.WriteTo(writer);
}
public RegionCookie(MarkupStreamWriter writer)
{
this.writer = writer;
}
/// <summary>
/// Writes the contents of the stream to a markup stream writer.
/// </summary>
/// <param name="writer">The writer.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="writer"/> is null.</exception>
public void WriteTo(MarkupStreamWriter writer)
{
if (writer == null)
throw new ArgumentNullException("writer");
if (body != null)
body.WriteTo(writer);
}