private static T FindWithAnnotation <T>(IntermediateNode node, object annotation) where T : IntermediateNode
{
if (node is T target && object.ReferenceEquals(target.Annotations[annotation], annotation))
{
return(target);
}
for (var i = 0; i < node.Children.Count; i++)
{
var result = FindWithAnnotation <T>(node.Children[i], annotation);
if (result != null)
{
return(result);
}
}
return(null);
}
public static void EndInstrumentation(IntermediateNode node)
{
try
{
var endNode = Assert.IsType <CSharpCodeIntermediateNode>(node);
var content = new StringBuilder();
for (var i = 0; i < endNode.Children.Count; i++)
{
var token = Assert.IsAssignableFrom <IntermediateToken>(endNode.Children[i]);
Assert.Equal(TokenKind.CSharp, token.Kind);
content.Append(token.Content);
}
Assert.Equal("EndContext();", content.ToString());
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(node, node.Children, e.Message, e);
}
}
internal static void PreallocatedTagHelperPropertyValue(
IntermediateNode node,
string attributeName,
string value,
AttributeStructure valueStyle)
{
var propertyValueNode = Assert.IsType <PreallocatedTagHelperPropertyValueIntermediateNode>(node);
try
{
Assert.Equal(attributeName, propertyValueNode.AttributeName);
Assert.Equal(value, propertyValueNode.Value);
Assert.Equal(valueStyle, propertyValueNode.AttributeStructure);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(propertyValueNode, e.Message);
}
}
internal static void TagHelperHtmlAttribute(
string name,
AttributeStructure valueStyle,
IntermediateNode node,
params Action <IntermediateNode>[] valueValidators)
{
var tagHelperHtmlAttribute = Assert.IsType <TagHelperHtmlAttributeIntermediateNode>(node);
try
{
Assert.Equal(name, tagHelperHtmlAttribute.AttributeName);
Assert.Equal(valueStyle, tagHelperHtmlAttribute.AttributeStructure);
Children(tagHelperHtmlAttribute, valueValidators);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(tagHelperHtmlAttribute, tagHelperHtmlAttribute.Children, e.Message, e);
}
}
public static void CSharpCode(string expected, IntermediateNode node)
{
try
{
var statement = Assert.IsType <CSharpCodeIntermediateNode>(node);
var content = new StringBuilder();
for (var i = 0; i < statement.Children.Count; i++)
{
var token = Assert.IsType <IntermediateToken>(statement.Children[i]);
Assert.Equal(TokenKind.CSharp, token.Kind);
content.Append(token.Content);
}
Assert.Equal(expected, content.ToString());
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(node, node.Children, e.Message, e);
}
}
public static void BeginInstrumentation(string expected, IntermediateNode node)
{
try
{
var beginNode = Assert.IsType <CSharpCodeIntermediateNode>(node);
var content = new StringBuilder();
for (var i = 0; i < beginNode.Children.Count; i++)
{
var token = Assert.IsAssignableFrom <IntermediateToken>(beginNode.Children[i]);
Assert.True(token.IsCSharp);
content.Append(token.Content);
}
Assert.Equal($"BeginContext({expected});", content.ToString());
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(node, node.Children, e.Message, e);
}
}
public static void Html(string expected, IntermediateNode node)
{
try
{
var html = Assert.IsType <HtmlContentIntermediateNode>(node);
var content = new StringBuilder();
for (var i = 0; i < html.Children.Count; i++)
{
var token = Assert.IsAssignableFrom <IntermediateToken>(html.Children[i]);
Assert.Equal(TokenKind.Html, token.Kind);
content.Append(token.Content);
}
Assert.Equal(expected, content.ToString());
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(node, node.Children, e.Message, e);
}
}
private void EndNode(IntermediateNode node)
{
if (_content != null && (_properties.Count == 0 || ContentMode == FormatterContentMode.PreferContent))
{
Writer.Write(" ");
Writer.Write("\"");
Writer.Write(EscapeNewlines(_content));
Writer.Write("\"");
}
if (_properties.Count > 0 && (_content == null || ContentMode == FormatterContentMode.PreferProperties))
{
Writer.Write(" ");
Writer.Write("{ ");
Writer.Write(string.Join(", ", _properties.Select(kvp => $"{kvp.Key}: \"{kvp.Value}\"")));
Writer.Write(" }");
}
_content = null;
_properties.Clear();
}
internal static void SetTagHelperProperty(
string name,
string propertyName,
AttributeStructure valueStyle,
IntermediateNode node,
params Action <IntermediateNode>[] valueValidators)
{
var propertyNode = Assert.IsType <TagHelperPropertyIntermediateNode>(node);
try
{
Assert.Equal(name, propertyNode.AttributeName);
Assert.Equal(propertyName, propertyNode.BoundAttribute.GetPropertyName());
Assert.Equal(valueStyle, propertyNode.AttributeStructure);
Children(propertyNode, valueValidators);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(propertyNode, propertyNode.Children, e.Message, e);
}
}
public static void ConditionalAttribute(
string prefix,
string name,
string suffix,
IntermediateNode node,
params Action <IntermediateNode>[] valueValidators)
{
var attribute = Assert.IsType <HtmlAttributeIntermediateNode>(node);
try
{
Assert.Equal(prefix, attribute.Prefix);
Assert.Equal(name, attribute.AttributeName);
Assert.Equal(suffix, attribute.Suffix);
Children(attribute, valueValidators);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(attribute, attribute.Children, e.Message, e);
}
}
public static void LiteralAttributeValue(string prefix, string expected, IntermediateNode node)
{
var attributeValue = Assert.IsType <HtmlAttributeValueIntermediateNode>(node);
try
{
var content = new StringBuilder();
for (var i = 0; i < attributeValue.Children.Count; i++)
{
var token = Assert.IsAssignableFrom <IntermediateToken>(attributeValue.Children[i]);
Assert.True(token.IsHtml);
content.Append(token.Content);
}
Assert.Equal(prefix, attributeValue.Prefix);
Assert.Equal(expected, content.ToString());
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(attributeValue, e.Message);
}
}
public override void VisitDefault(IntermediateNode node)
{
var children = node.Children;
if (node.Children.Count == 0)
{
return;
}
_ancestors.Insert(0, node);
try
{
for (var i = 0; i < node.Children.Count; i++)
{
var child = children[i];
Visit(child);
}
}
finally
{
_ancestors.RemoveAt(0);
}
}
public override void Push(IntermediateNode node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (_depth >= _stack.Count)
{
_stack.Add(node);
}
else
{
_stack[_depth] = node;
}
if (_depth > 0)
{
var parent = _stack[_depth - 1];
parent.Children.Add(node);
}
_depth++;
}
public static void AnnotationEquals(IntermediateNode node, object value)
{
AnnotationEquals(node, value, value);
}
public IntermediateNodeAssertException(IntermediateNode node, IEnumerable <IntermediateNode> nodes, string userMessage)
: base(Format(node, null, nodes, userMessage))
{
Node = node;
Nodes = nodes;
}
public IntermediateNodeAssertException(IntermediateNode node, string userMessage)
: base(Format(node, null, null, userMessage))
{
Node = node;
}
internal static void TagHelper(string tagName, TagMode tagMode, IEnumerable <TagHelperDescriptor> tagHelpers, IntermediateNode node, params Action <IntermediateNode>[] childValidators)
{
var tagHelperNode = Assert.IsType <TagHelperIntermediateNode>(node);
try
{
Assert.Equal(tagName, tagHelperNode.TagName);
Assert.Equal(tagMode, tagHelperNode.TagMode);
Assert.Equal(tagHelpers, tagHelperNode.TagHelpers, TagHelperDescriptorComparer.Default);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(tagHelperNode, e.Message);
}
Children(node, childValidators);
}
public static bool IsImported(this IntermediateNode node)
{
return(ReferenceEquals(node.Annotations[CommonAnnotations.Imported], CommonAnnotations.Imported));
}
public abstract void Add(IntermediateNode node);
public void Deconstruct(out IntermediateNode parent, out IntermediateNode node)
{
parent = Parent;
node = Node;
}
public static void DirectiveToken(DirectiveTokenKind expectedKind, string expectedContent, IntermediateNode node)
{
try
{
var token = Assert.IsType <DirectiveTokenIntermediateNode>(node);
Assert.Equal(expectedKind, token.DirectiveToken.Kind);
Assert.Equal(expectedContent, token.Content);
}
catch (XunitException e)
{
throw new IntermediateNodeAssertException(node, node.Children, e.Message, e);
}
}
public abstract void Push(IntermediateNode node);
public abstract void Insert(int index, IntermediateNode node);