public static XObjectWrapper MakeWrapper(XText obj)
 {
     if (obj is XCData)
         return MakeWrapper((XCData)obj);
     else
         return new XTextWrapper(obj);
 }

 private static XText CalibrateText(XText n)
 {
     if (n.parent == null)
     {
         return n;
     }
     XNode content = (XNode) n.parent.content;
     while (true)
     {
         content = content.next;
         XText text = content as XText;
         if (text != null)
         {
             do
             {
                 if (content == n)
                 {
                     return text;
                 }
                 content = content.next;
             }
             while (content is XText);
         }
     }
 }

 private void ProcessXText(XText xtext, StringBuilder sb, bool performReplacements)
 {
     //.NET likes to just drop out some of the formatting, specially the " which becomes normal old double quotes.
     var correctedText = XmlTextEncoder.Encode(xtext.Value);
     var newvalue = performReplacements ? Replace(correctedText) : correctedText;
     sb.Append(newvalue);
 }

 public Service(XElement baseElement, Product parent)
 {
     _nameAndRev = baseElement.Elements(_ns + "span").Nodes().OfType<XText>().FirstOrDefault();
       _amountSpan = baseElement.Elements(_ns + "span").Elements(_ns + "span").Nodes().OfType<XText>().ToList();
       _options = new List<Option>();
       Product = parent;
 }

                //[Variation(Priority = 3, Desc = "Adjacent text nodes II. (sanity)")]
                public void AdjacentTextNodes2()
                {
                    XText t1 = new XText("a");
                    XElement e = new XElement("root", "hello");
                    e.Add(t1);

                    VerifyOrder(e.FirstNode, t1, -1);
                }

                //[Variation(Priority = 3, Desc = "Adjacent text nodes I. (sanity)")]
                public void AdjacentTextNodes1()
                {
                    XText t1 = new XText("a");
                    XText t2 = new XText("");
                    XElement e = new XElement("root", t1, t2);

                    VerifyOrder(t1, t2, -1);
                }

 public XText(XText other)
 {
     if (other == null)
     {
         throw new ArgumentNullException("other");
     }
     this.text = other.text;
 }

 public void Test_text_node()
 {
     var tx = new XText("This is some text");
     var e1 = new XElement("Root", tx);
     var d1 = new XDocument(e1);
     var di = d1.GetObjectId();
     var id = e1.GetObjectId();
     var ti = tx.GetObjectId();
     var d2 = XNodeAnnotationSerializer.Serialize(d1);
     var d3 = XNodeAnnotationSerializer.Deserialize(d2);
     Assert.IsTrue(d3.Root.FirstNode.GetObjectId() == ti);
 }

 private void ReplaceFields()
 {
     var elements = DocumentContent.XPathSelectElements( @"//text:text-input[ @text:description = 'Template']",
                                                         Manager );
     var nodes = elements.ToList();
     foreach( var element in nodes )
     {
         var attribute = element.Value;
         var preparedAttribute = attribute.Replace( "U+10FFFD", "@" );
         var text = new XText( preparedAttribute );
         element.ReplaceWith( text );
     }
 }

        private void CreateControlFlowFromComment( XElement comment )
        {
            var row = comment.XPathSelectElement( "./ancestor::table:table-row", Manager );
            var commentValue = comment.Value.Replace( "U+10FFFD", "@" );

            var beforeNode = new XText( commentValue + "{" );

            var afterNode = new XText( "}" );

            row.AddBeforeSelf( beforeNode );
            row.AddAfterSelf( afterNode );
            comment.Remove();
        }

	/// <summary>
	/// Encodes a string for use in an XML element or attribute.
	/// </summary>
	/// <param name="value" this="true">The value to encode in XML compatible way.</param>
	/// <returns>The XML encoded string.</returns>
	public static string XmlEncode(this string value)
	{
		Guard.NotNull(() => value, value);

		var output = new StringBuilder();
		var text = new XText(value);

		using (var writer = XmlWriter.Create(output, new XmlWriterSettings { ConformanceLevel = ConformanceLevel.Fragment }))
		{
			text.WriteTo(writer);
			writer.Flush();
			return output.ToString();
		}
	}

                //[Variation(Desc = "NodeTypes")]
                public void NodeTypes()
                {
                    XDocument document = new XDocument();
                    XElement element = new XElement("x");
                    XText text = new XText("text-value");
                    XComment comment = new XComment("comment");
                    XProcessingInstruction processingInstruction = new XProcessingInstruction("target", "data");

                    Validate.IsEqual(document.NodeType, XmlNodeType.Document);
                    Validate.IsEqual(element.NodeType, XmlNodeType.Element);
                    Validate.IsEqual(text.NodeType, XmlNodeType.Text);
                    Validate.IsEqual(comment.NodeType, XmlNodeType.Comment);
                    Validate.IsEqual(processingInstruction.NodeType, XmlNodeType.ProcessingInstruction);
                }

 /// <summary>
 /// Write as C# code.
 /// </summary>
 private static void WriteAsCode(XText text, CommentSection section, bool inCode)
 {
     var lineNo = 0;
     var content = text.Value;
     if (string.IsNullOrEmpty(content))
         return;
     foreach (var part in content.Split('\n'))
     {
         if ((lineNo > 0) && inCode)
             section.WriteLine();
         section.Write(part.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;"));
         lineNo++;
     }
 }

        public void NodeTypes()
        {
            XDocument document = new XDocument();
            XElement element = new XElement("x");
            XText text = new XText("text-value");
            XComment comment = new XComment("comment");
            XProcessingInstruction processingInstruction = new XProcessingInstruction("target", "data");

            Assert.Equal(XmlNodeType.Document, document.NodeType);
            Assert.Equal(XmlNodeType.Element, element.NodeType);
            Assert.Equal(XmlNodeType.Text, text.NodeType);
            Assert.Equal(XmlNodeType.Comment, comment.NodeType);
            Assert.Equal(XmlNodeType.ProcessingInstruction, processingInstruction.NodeType);
        }

 private static string CollectText(XText n)
 {
     string str = n.Value;
     if (n.parent != null)
     {
         while (n != n.parent.content)
         {
             n = n.next as XText;
             if (n == null)
             {
                 return str;
             }
             str = str + n.Value;
         }
     }
     return str;
 }

        private void CreateControlFlowSection( XElement script )
        {
            //TODO: Test this method

            var parentSection = script.XPathSelectElement( "./ancestor::text:section", Manager );
            // TODO: If ParentSection is null, throw specific exception

            var scriptValue = script.Value.Replace( "U+10FFFD", "@" );

            var beforeNode = new XText( scriptValue + "{" );

            var afterNode = new XText( "}" );

            parentSection.AddBeforeSelf( beforeNode );

            parentSection.AddAfterSelf( afterNode );

            script.Remove();
        }

    public void Parent()
    {
      JArray v = new JArray(new JConstructor("TestConstructor"), new JValue(new DateTime(2000, 12, 20)));

      Assert.AreEqual(null, v.Parent);

      JObject o =
        new JObject(
          new JProperty("Test1", v),
          new JProperty("Test2", "Test2Value"),
          new JProperty("Test3", "Test3Value"),
          new JProperty("Test4", null)
        );

      Assert.AreEqual(o.Property("Test1"), v.Parent);

      JProperty p = new JProperty("NewProperty", v);

      // existing value should still have same parent
      Assert.AreEqual(o.Property("Test1"), v.Parent);

      // new value should be cloned
      Assert.AreNotEqual(p.Value, v);

      Assert.AreEqual((DateTime)((JValue)p.Value[1]).Value, (DateTime)((JValue)v[1]).Value);

      Assert.AreEqual(v, o["Test1"]);

      XText t = new XText("XText");
      Assert.AreEqual(null, t.Parent);

      Assert.AreEqual(null, o.Parent);
      JProperty o1 = new JProperty("O1", o);
      Assert.AreEqual(o, o1.Value);

      Assert.AreNotEqual(null, o.Parent);
      JProperty o2 = new JProperty("O2", o);

      Assert.AreNotEqual(o1.Value, o2.Value);
      Assert.AreEqual(o1.Value.Children().Count(), o2.Value.Children().Count());
      Assert.AreEqual(false, JToken.DeepEquals(o1, o2));
      Assert.AreEqual(true, JToken.DeepEquals(o1.Value, o2.Value));
    }

 public void ExecuteXDocumentVariation(XNode toReplace)
 {
     XNode newValue = new XText(" ");
     XDocument xDoc = new XDocument(toReplace);
     XDocument xDocOriginal = new XDocument(xDoc);
     using (UndoManager undo = new UndoManager(xDoc))
     {
         undo.Group();
         using (EventsHelper docHelper = new EventsHelper(xDoc))
         {
             xDoc.ReplaceNodes(newValue);
             Assert.True(xDoc.Nodes().Count() == 1, "Not all content were removed");
             Assert.True(Object.ReferenceEquals(xDoc.FirstNode, newValue), "Did not replace correctly");
             docHelper.Verify(new XObjectChange[] { XObjectChange.Remove, XObjectChange.Add }, new XObject[] { toReplace, newValue });
         }
         undo.Undo();
         Assert.True(XNode.DeepEquals(xDoc, xDocOriginal), "Undo did not work!");
     }
 }

 IEnumerable<XElement> CreateRuns(XText node,bool preservespace)
 {
     var rtn = new List<XElement>();
     if(!preservespace)
     {
         var run = CreateRun(GetInnerText(node.Value, false));
         rtn.Add(run);
         return rtn;
     }
     var lines = node.Value.Split(new char[] {'\r', '\n'}, StringSplitOptions.RemoveEmptyEntries);
     foreach(var line in lines)
     {
         var run = CreateRun(line);
         rtn.Add(run);
         rtn.Add(CreateLineBreak());
     }
     if (rtn.Count > 0)
         rtn.Remove(rtn.Last());
     return rtn;
 } 

        private void handle_blog_archive_page(System.Net.HttpListenerContext context)
        {
            this.WriteLogMethodName();

            var xdoc = CreateHtmlDom();
            var el_body = xdoc.Element("html").Element("body");
            el_body.AddH1Element(this.BlogTitle);

            el_body.AddAnchorElement("/", "Home");
            foreach (var post in this.PostList)
            {
                var el_para = el_body.AddParagraphElement();
                var el_text =
                    new System.Xml.Linq.XText(post.DateCreated == null
                        ? "No Publish Date"
                        : post.DateCreated.Value.ToShortDateString());
                el_para.Add(el_text);

                el_para.AddAnchorElement(post.Link, post.Title);
            }
            WriteResponseString(context, xdoc.ToString(), 200, ContentType_TextHtml);
        }