public static XmlNode CreateNode(XmlNodeType type, string name)
        {
            XmlDocument document = new XmlDocument();
            XmlNode node = document.CreateNode(type, name, null);

            return node;
        }

    public static object LoadXml(string fragment, XmlNodeType xmlNodeType, object target, string filename)
    {
      XamlParser parser = new XamlParser();
      parser._filename = filename;

      return parser.Read(fragment, xmlNodeType, target);
    }

		void AssertNode (int depth, string localName, XmlNodeType nodeType, string value, string type, XmlDictionaryReader reader, string label)
		{
			Assert.AreEqual (localName, reader.LocalName, label + ".LocalName");
			Assert.AreEqual (nodeType, reader.NodeType, label + ".NodeType");
			Assert.AreEqual (value, reader.Value, label + ".Value");
			Assert.AreEqual (type, reader.GetAttribute ("type"), label + ".GetAttribute('type')");
		}

        public void AdvanceNode(XmlNodeType xmlNodeType)
        {
            AdvanceNode();

            if (m_xmlReader.NodeType != xmlNodeType)
                throw new Exception("The expected node is " + xmlNodeType);
        }

        private static void VerifyOwnerOfGivenType(XmlNodeType nodeType)
        {
            var xmlDocument = new XmlDocument();
            var node = xmlDocument.CreateNode(nodeType, "test", string.Empty);

            Assert.Equal(xmlDocument, node.OwnerDocument);
        }

 public ParserNode(string name, string value, XmlNodeType nodeType)
 {
     Name = name;
     Value = value;
     NodeType = nodeType;
     Attributes = new Dictionary<string, string>();
 }

        /// <summary>
        /// Initializes a new instance of the OpenXmlMiscNode class using the
        /// supplied XmlNodeType and outer XML values.
        /// </summary>
        /// <param name="nodeType">The XmlNodeType value.</param>
        /// <param name="outerXml">The outer XML of the element.</param>
        public OpenXmlMiscNode(XmlNodeType nodeType, string outerXml)
            : this(nodeType)
        {
            if ( String.IsNullOrEmpty( outerXml ) )
            {
                throw new ArgumentNullException("outerXml");
            }
            
            // check the out XML match the nodeType
            using (StringReader stringReader = new StringReader(outerXml))
            {
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.DtdProcessing = DtdProcessing.Prohibit; // set true explicitly for serucity fix
                using (XmlReader xmlReader = XmlConvertingReaderFactory.Create(stringReader, settings))
                {
                    xmlReader.Read();
                
                    if (xmlReader.NodeType != nodeType)
                    {
                        throw new ArgumentException(ExceptionMessages.InvalidOuterXmlForMiscNode);
                    }

                    xmlReader.Close();
                }
            }

            this.RawOuterXml = outerXml;
        }

 public XmlValidatingReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) {
     if (xmlFragment == null) {
         throw new ArgumentNullException("xmlFragment");
     }
     impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
     impl.OuterReader = this;
 }

		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType");
			Assert.AreEqual (depth, xmlReader.Depth, "Depth");
			Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement");

			Assert.AreEqual (name, xmlReader.Name, "name");

			Assert.AreEqual (prefix, xmlReader.Prefix, "prefix");

			Assert.AreEqual (localName, xmlReader.LocalName, "localName");

			Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI");

			Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue");

			Assert.AreEqual (value, xmlReader.Value, "Value");

			Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes");

			Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount");
		}

 /// <summary>
 /// Consumes nodes from the reader until the first ocurance of the XmlNodeType identified within types.
 /// </summary>
 /// <param name="reader">The reader from which to consume Xml nodes</param>
 /// <param name="types">The XmlNodeType types of interest which will halt consumption</param>
 public static void ConsumeUntilFirst(this XmlReader reader, XmlNodeType[] types)
 {
     while (Array.IndexOf(types, reader.NodeType) < 0)
     {
         reader.Read();
     }
 }

        internal override bool IsValidChildType(XmlNodeType type)
        {
            switch (type)
            {
                case XmlNodeType.Element:
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                case XmlNodeType.EntityReference:
                case XmlNodeType.ProcessingInstruction:
                case XmlNodeType.Comment:
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    return true;

                case XmlNodeType.XmlDeclaration:
                {
                    XmlNode firstChild = this.FirstChild;
                    if ((firstChild != null) && (firstChild.NodeType == XmlNodeType.XmlDeclaration))
                    {
                        return false;
                    }
                    return true;
                }
            }
            return false;
        }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="value">innerText for this node</param>
 /// <param name="nodeType">type of node</param>
 internal XmlDiffViewCharData(
     string value,
     XmlNodeType nodeType)
     : base(nodeType)
 {
     this.InnerText = value;
 }

 public override void Close()
 {
     this.nav = XmlEmptyNavigator.Singleton;
     this.nodeType = XmlNodeType.None;
     this.state = State.Closed;
     this.depth = 0;
 }

		private void AssertNodeValues (
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			int attributeCount)
		{
			AssertEquals ("NodeType", nodeType, xmlReader.NodeType);
			AssertEquals ("Depth", depth, xmlReader.Depth);
			AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);

			AssertEquals ("name", name, xmlReader.Name);

			AssertEquals ("prefix", prefix, xmlReader.Prefix);

			AssertEquals ("localName", localName, xmlReader.LocalName);

			AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI);

			AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue);

			AssertEquals ("Value", value, xmlReader.Value);

			AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes);

			AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount);
		}

        private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType)
        {
            XmlNode parent = xmlDocument.DocumentElement;
            XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild;
            XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType);

            string original = parent.InnerXml;
            string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml)
                : ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml)
                : (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml));

            // insert new child
            var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType);
            insertDelegate(parent, newChild, refChild);

            // verify
            Assert.Equal(3, parent.ChildNodes.Count);
            Assert.Equal(expected, parent.InnerXml);

            TestHelper.Verify(parent, refChild, newChild);
            TestHelper.VerifySiblings(refChild, newChild, insertType);

            if (insertType == InsertType.Prepend || insertType == InsertType.Append)
                TestHelper.Verify(refChild, newChild, insertType);

            // delete new child
            parent.RemoveChild(newChild);
            Assert.Equal(2, parent.ChildNodes.Count);
            TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append);
            Assert.Equal(original, parent.InnerXml);
        }

 private XmlToken(XmlNodeType kind)
 {
     _Name = null;
     _Kind = kind;
     _Value = null;
     _LineNumber = null;
     _LinePosition = null;
 }

 internal XmlBasicTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, int depth) {
     _Scanner = scanner;                
     _NsMgr = nsMgr;        
     _NodeType = type;        
     _Depth = depth;                
     _LineNum = 0;
     _LinePos = 0;
 } 

        public void AdvanceNamedNode(XmlNodeType xmlNodeType, string nodeName)
        {
            AdvanceNode(xmlNodeType);

            if (m_xmlReader.Name != nodeName)
                throw new Exception("Node '" + nodeName + "' of type '"
                    + xmlNodeType + "' expected");
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="NodeHandlerAttribute"/> class.
        /// </summary>
        /// <param name="nodeType">The type of the node being handled.</param>
        /// <param name="nodeName">The name of the node being handled.</param>
        /// <param name="ns">The namespace of the node being handled.</param>
        public NodeHandlerAttribute(XmlNodeType nodeType, string nodeName, string ns = null)
        {
            Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(nodeName));

            this.NodeType = nodeType;
            this.NodeName = nodeName.Substring(nodeName.IndexOf(":", StringComparison.Ordinal) + 1);
            this.Namespace = ns;
        }

 //********************************************************************************
 /// <summary>
 /// 
 /// </summary>
 /// <returns></returns>
 /// <created>UPh,20.03.2013</created>
 /// <changed>UPh,20.03.2013</changed>
 //********************************************************************************
 public CXmlNode()
 {
     m_nDepth = 0;
     m_nNodeType = XmlNodeType.None;
     m_bEmptyElement = false;
     m_pReader = null;
     m_pWriter = null;
 }