public void XElementWorkOnTextNodes1()
{
XElement elem = new XElement("A", "text2");
XNode n = elem.FirstNode;
using (UndoManager undo = new UndoManager(elem))
{
undo.Group();
using (EventsHelper eHelper = new EventsHelper(elem))
{
n.AddBeforeSelf("text0");
Assert.Equal("text0text2", elem.Value);
n.AddBeforeSelf("text1");
Assert.Equal("text0text1text2", elem.Value);
eHelper.Verify(new XObjectChange[] { XObjectChange.Add, XObjectChange.Value });
}
undo.Undo();
Assert.Equal("text2", elem.Value);
}
}
/// <summary>
/// Ensures the whitespace separation between two nodes. Appropriate whitespace is added before the given node
/// </summary>
/// <param name="first"></param>
private XText EnsureWhitespaceBeforeNode(XNode node)
{
Debug.Assert(
node.Parent != null && node.Parent.Elements().Count() > 0,
"Call EnsureFirstNodeWhitespaceSeparation when the added element is the first node");
var newLine = new XText(Environment.NewLine + new string(' ', GetIndentLevel() * 2));
node.AddBeforeSelf(newLine);
return(newLine);
}
//[Variation(Priority = 1, Desc = "Working on the text nodes 1.")]
public void WorkOnTextNodes1()
{
runWithEvents = (bool)Params[0];
var elem = new XElement("A", new XElement("B"), "text2", new XElement("C"));
XNode n = elem.FirstNode.NextNode;
if (runWithEvents)
{
eHelper = new EventsHelper(elem);
}
n.AddBeforeSelf("text0");
n.AddBeforeSelf("text1");
if (runWithEvents)
{
eHelper.Verify(new[] { XObjectChange.Add, XObjectChange.Value });
}
TestLog.Compare(elem.Nodes().Count(), 4, "elem.Nodes().Count(), 4");
TestLog.Compare((n as XText).Value, "text2", "(n as XText).Value, text2");
TestLog.Compare((n.PreviousNode as XText).Value, "text0text1", "(n as XText).Value, text0text1");
}
public bool Visit(XNode node)
{
if (node is XElement asElement)
{
if (asElement.HasElements)
{
asElement.Add(_newlineText);
}
if (!"Project".Equals(asElement.Name.LocalName, StringComparison.OrdinalIgnoreCase))
{
node.AddBeforeSelf(_newlineText);
}
}
else if (node.NodeType == XmlNodeType.Comment)
{
node.AddBeforeSelf(_newlineText);
}
return(true);
}
public void AddOrUpdateElement(string name, string value)
{
var child = Element.Elements().FirstOrDefault(x => x.Name.LocalName == name);
if (child != null)
{
child.Value = value;
}
else
{
if (_closingElementSpace == null)
{
_closingElementSpace = new XText("\r\n" + new string(' ', (Depth) * 2));
Element.Add(_closingElementSpace);
}
child = new XElement(XName.Get(name));
child.Add(value);
_closingElementSpace.AddBeforeSelf(child);
child.AddBeforeSelf(new XText("\r\n" + new string(' ', (Depth + 1) * 2)));
}
}
/// <summary>
/// Returns an XDocument where the XElement instances are
/// positioned at the exact same line number as the original xml source.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
private static XDocument AdjustLineNumbers(XDocument input)
{
XDocument result;
// save input to stream and re-read
using (var stream = new MemoryStream()) {
input.Save(stream, SaveOptions.DisableFormatting);
stream.Seek(0, SeekOrigin.Begin);
// read serialized xml
result = XDocument.Load(stream, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
}
// find line info on each element and insert whitespace where needed
var offset = 0;
foreach (var element in result.Descendants())
{
var lineInfo = (IXmlLineInfo)element;
var originalLineAttr = element.Attribute(LineNumberName);
if (originalLineAttr == null)
{
continue;
}
int originalLineNumber;
if (int.TryParse((string)originalLineAttr, NumberStyles.Integer, CultureInfo.InvariantCulture, out originalLineNumber))
{
if (originalLineNumber > lineInfo.LineNumber + offset)
{
var count = originalLineNumber - lineInfo.LineNumber - offset;
var whitespace = new XText(string.Join(Environment.NewLine, new string[count + 1]));
offset += count;
// insert newlines before whitespace of element
XNode node = element;
while (node.PreviousNode != null && IsWhitespace(node.PreviousNode))
{
node = node.PreviousNode;
}
node.AddBeforeSelf(whitespace);
}
}
// and remove line number attribute
originalLineAttr.Remove();
}
return(result);
}
public bool Visit(XNode node)
{
if (node.NodeType == XmlNodeType.Element)
{
node.AddBeforeSelf(new XText("\n"));
if (node.NodesAfterSelf().All(x => x.NodeType == XmlNodeType.Text))
{
node.AddAfterSelf(new XText("\n"));
}
}
return(false);
}
/// <summary>
/// Moves the element up.
/// </summary>
/// <param name="element">The element.</param>
/// <exception cref="System.ArgumentException">Nowhere to move element to!</exception>
public static void MoveElementUp(this XElement element)
{
// Walk backwards until we find an element - ignore text nodes
XNode previousNode = element.PreviousNode;
while (previousNode != null && !(previousNode is XElement))
{
previousNode = previousNode.PreviousNode;
}
if (previousNode == null)
{
throw new ArgumentException("Nowhere to move element to!");
}
element.Remove();
previousNode.AddBeforeSelf(element);
}
//[Variation(Priority = 1, Desc = "XElement - Working on the text nodes 2.")]
public void WorkOnTextNodes2()
{
XElement elem = new XElement("A", "text2");
XNode n = elem.FirstNode;
using (UndoManager undo = new UndoManager(elem))
{
undo.Group();
using (EventsHelper eHelper = new EventsHelper(elem))
{
n.AddBeforeSelf("text0", "text1");
TestLog.Compare(elem.Value, "text0text1text2", "Did not concat text nodes correctly");
eHelper.Verify(XObjectChange.Add);
}
undo.Undo();
TestLog.Compare(elem.Value, "text2", "Undo did not work");
}
}
/// <summary>
/// Ensures the whitespace separation for the first child element added to a node.
/// </summary>
/// <param name="element"></param>
private void EnsureFirstNodeWhitespaceSeparation(XNode element)
{
#if DEBUG
if (element.Parent != null)
{
Debug.Assert(element.Parent.Elements().Count() == 1, "Unexpected count of elements!");
}
else
{
// if first.Parent is null, then this is the root element in a document
Debug.Assert(element.Document.Root == element, "element had null parent, but is not the root element of the document");
}
#endif
var precedingNewLine = new XText(Environment.NewLine + new string(' ', GetIndentLevel() * 2));
var trailingNewLine = new XText(Environment.NewLine + new string(' ', Parent.GetIndentLevel() * 2));
element.AddBeforeSelf(precedingNewLine);
element.AddAfterSelf(trailingNewLine);
}
public static XElement MoveBefore(this XElement element, XNode target)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (element != target)
{
if (element.Parent != null)
{
element.Remove();
}
if (target.Parent != null)
{
target.AddBeforeSelf(element);
}
}
return(element);
}
public void ExecuteXDocumentVariation(XNode[] toAdd, XNode contextNode)
{
IEnumerable <XNode> toAddList = toAdd.OfType <XNode>();
XDocument xDoc = new XDocument(contextNode);
XDocument xDocOriginal = new XDocument(xDoc);
using (UndoManager undo = new UndoManager(xDoc))
{
undo.Group();
using (EventsHelper docHelper = new EventsHelper(xDoc))
{
using (EventsHelper nodeHelper = new EventsHelper(contextNode))
{
contextNode.AddBeforeSelf(toAdd);
Assert.True(toAddList.SequenceEqual(contextNode.NodesBeforeSelf(), XNode.EqualityComparer), "Nodes not added correctly!");
nodeHelper.Verify(0);
}
docHelper.Verify(XObjectChange.Add, toAdd);
}
undo.Undo();
Assert.True(XNode.DeepEquals(xDoc, xDocOriginal), "Undo did not work!");
}
}
public void ExecuteXElementVariation(XNode[] toAdd, XNode contextNode)
{
IEnumerable <XNode> toAddList = toAdd.OfType <XNode>();
XElement xElem = new XElement("root", contextNode);
XElement xElemOriginal = new XElement(xElem);
using (UndoManager undo = new UndoManager(xElem))
{
undo.Group();
using (EventsHelper elemHelper = new EventsHelper(xElem))
{
using (EventsHelper nodeHelper = new EventsHelper(contextNode))
{
contextNode.AddBeforeSelf(toAdd);
Assert.True(toAddList.SequenceEqual(contextNode.NodesBeforeSelf(), XNode.EqualityComparer), "Nodes not added correctly!");
nodeHelper.Verify(0);
}
elemHelper.Verify(XObjectChange.Add, toAdd);
}
undo.Undo();
Assert.True(xElem.Nodes().SequenceEqual(xElemOriginal.Nodes(), XNode.EqualityComparer), "Undo did not work!");
Assert.True(xElem.Attributes().EqualsAllAttributes(xElemOriginal.Attributes(), Helpers.MyAttributeComparer), "Undo did not work!");
}
}
//[Variation(Desc = "Tuple - New Dev10 Types", Param = 1)]
//[Variation(Desc = "DynamicObject - New Dev10 Types", Param = 2)]
//[Variation(Desc = "Guid - old type", Param = 3)]
//[Variation(Desc = "Dictionary - old type", Param = 4)]
public void CreatingXElementsFromNewDev10Types()
{
object t = null;
Type type = typeof(object);
int param = (int)this.Variation.Param;
switch (param)
{
case 1: t = Tuple.Create(1, "Melitta", 7.5); type = typeof(Tuple); break;
case 3: t = new Guid(); type = typeof(Guid); break;
case 4: t = new Dictionary <int, string>(); ((Dictionary <int, string>)t).Add(7, "a"); type = typeof(Dictionary <int, string>); break;
}
XElement e = new XElement("e1",
new XElement("e2"), "text1",
new XElement("e3"), t);
e.Add(t);
e.FirstNode.ReplaceWith(t);
XNode n = e.FirstNode.NextNode;
n.AddBeforeSelf(t);
n.AddAnnotation(t);
n.ReplaceWith(t);
e.FirstNode.AddAfterSelf(t);
e.AddFirst(t);
e.Annotation(type);
e.Annotations(type);
e.RemoveAnnotations(type);
e.ReplaceAll(t);
e.ReplaceAttributes(t);
e.ReplaceNodes(t);
e.SetAttributeValue("a", t);
e.SetElementValue("e2", t);
e.SetValue(t);
XAttribute a = new XAttribute("a", t);
XStreamingElement se = new XStreamingElement("se", t);
se.Add(t);
try
{
new XDocument(t);
}
catch (ArgumentException)
{
try
{
new XDocument(t);
}
catch (ArgumentException)
{
return;
}
}
TestLog.Compare(false, "Failed");
}
