public void Constructor2 ()
		{
			XmlDocument doc = new XmlDocument ();
			XmlNamespaceManager ns = new XmlNamespaceManager (doc.NameTable);

			XmlParserContext pc = new XmlParserContext (doc.NameTable,
				ns, "dunno", XmlSpace.None, Encoding.UTF8);
			Assert.AreEqual (string.Empty, pc.BaseURI, "#A1");
			Assert.AreEqual (string.Empty, pc.DocTypeName, "#A2");
			Assert.AreEqual (Encoding.UTF8, pc.Encoding, "#A3");
			Assert.AreEqual (string.Empty, pc.InternalSubset, "#A4");
			Assert.AreSame (ns, pc.NamespaceManager, "#A5");
			Assert.AreSame (doc.NameTable, pc.NameTable, "#A6");
			Assert.AreEqual (string.Empty, pc.PublicId, "#A7");
			Assert.AreEqual (string.Empty, pc.SystemId, "#A8");
			Assert.AreEqual ("dunno", pc.XmlLang, "#A9");
			Assert.AreEqual (XmlSpace.None, pc.XmlSpace, "#A10");

			pc = new XmlParserContext ((NameTable) null, (XmlNamespaceManager) null,
				(string) null, XmlSpace.None, (Encoding) null);
			Assert.AreEqual (string.Empty, pc.BaseURI, "#B1");
			Assert.AreEqual (string.Empty, pc.DocTypeName, "#B2");
			Assert.IsNull (pc.Encoding, "#B3");
			Assert.AreEqual (string.Empty, pc.InternalSubset, "#B4");
			Assert.IsNull (pc.NamespaceManager, "#B5");
			Assert.IsNull (pc.NameTable, "#B6");
			Assert.AreEqual (string.Empty, pc.PublicId, "#B7");
			Assert.AreEqual (string.Empty, pc.SystemId, "#B8");
			Assert.AreEqual (string.Empty, pc.XmlLang, "#B9");
			Assert.AreEqual (XmlSpace.None, pc.XmlSpace, "#B10");
		}

        public static string ExtractQuery(string fileName, TextWriter errorlogger)
        {
            try
            {
                string data = File.ReadAllText(fileName);
                XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None);
                Stream xmlFragment = new MemoryStream(Encoding.UTF8.GetBytes(data));
                XmlTextReader reader = new XmlTextReader(xmlFragment, XmlNodeType.Element, context);
                reader.MoveToContent();
                if (reader.NodeType == XmlNodeType.Text)
                {
                    return data;
                }
                XmlReader reader2 = reader.ReadSubtree();
                StringBuilder output = new StringBuilder();
                using (XmlWriter writer = XmlWriter.Create(output))
                {
                    writer.WriteNode(reader2, true);
                }

                StringReader reader3 = new StringReader(data);
                for (int i = 0; i < reader.LineNumber; i++)
                {
                    reader3.ReadLine();
                }
                return reader3.ReadToEnd().Trim();
            }
            catch (Exception ex)
            {
                errorlogger.WriteLine(ex.Message);
                errorlogger.WriteLine(ex.StackTrace);
            }

            return string.Format("//Error loading the file - {0} .The the linq file might be a linqpad expression which is not supported in the viewer currently." ,fileName);
        }

        public static List<Issue> GetIssueListFromXmlStream(Stream stream) {
            List<Issue> issues = new List<Issue>();
            XmlTextReader reader = new XmlTextReader(stream);
            XmlDocument doc = new XmlDocument();
            doc.Load(reader);
            reader.Close();
            XmlNodeList list = doc.DocumentElement.GetElementsByTagName("item");
            XmlSerializer s = new XmlSerializer(typeof(Issue));
            //Create the XmlNamespaceManager.
            NameTable nt = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
            nsmgr.AddNamespace("jc", "urn:jiraconn");

            //Create the XmlParserContext.
            XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            foreach (XmlNode item in list)
            {
                //Create the reader. 
                XmlTextReader itemReader = new XmlTextReader(item.OuterXml, XmlNodeType.Element, context);
                Issue issue = (Issue)s.Deserialize(itemReader);
                issues.Add(issue);
            }

            return issues;
            
        }

        public string RenderComponentFieldAsBBCode(string fieldExpression, int fieldIndex, bool outputImages)
        {
            BuiltInFunctions functions = new BuiltInFunctions(_engine, _package);
            string output = functions.RenderComponentField(fieldExpression, fieldIndex);

            StringReader sr = new StringReader(output);
            NameTable nt = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
            nsmgr.AddNamespace("tcdl", Tridion.ContentManager.Templating.TcdlTags.TcdlNamespace);
            XmlParserContext parserContext = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            XmlReader xmlReader = XmlReader.Create(sr, new XmlReaderSettings(), parserContext);

            XslCompiledTransform transform = new XslCompiledTransform(true);

            using (Stream xsltStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Tridion.ContentManager.Templating.Expression.NetbiscuitsFunctions.XhtmlToBBCode.xslt"))
            {
                using (XmlReader xsltReader = XmlReader.Create(xsltStream))
                {
                    transform.Load(xsltReader);
                }
            }

            StringWriter resultWriter = new StringWriter();
            XsltArgumentList argumentList = new XsltArgumentList();
            argumentList.AddParam("IncludeImages", String.Empty, outputImages);

            transform.Transform(xmlReader, argumentList, resultWriter);

            return resultWriter.ToString();   
        }

        /// <summary>
        /// Validates XML definition against given XSD schema.
        /// </summary>
        /// <param name="xmlFileName">Full path to the XML file on file system.</param>
        /// <param name="schemaContent">XSD schema.</param>
        /// <param name="schemaName">XSD schema name.</param>
        public void Validate(string xmlFileName, string schemaContent, string schemaName)
        {
            _xmlFileName = xmlFileName;

            var xmlDoc = GetUpdatedXml(xmlFileName, schemaName);
            var xmlSchemaSet = GetXmlSchema(schemaContent, schemaName);

            var nt = new NameTable();
            var nsmgr = new XmlNamespaceManager(nt);
            var context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

            var settings = new XmlReaderSettings();
            settings.ValidationType = ValidationType.Schema;
            settings.Schemas.Add(xmlSchemaSet);
            settings.ValidationEventHandler += ValidationCallbackOne;

            using (var xmlr = new XmlTextReader(xmlDoc.OuterXml, XmlNodeType.Document, context))
            {
                using (var reader = XmlReader.Create(xmlr, settings))
                {
                    while (reader.Read())
                    {
                        var val = reader.Value;
                    }
                }
            }
        }

		/// <summary>
		/// Implements the following function
		/// node-set exsl:node-set(object)
		/// </summary>
		/// <param name="o"></param>
		/// <returns></returns>        
        public XPathNodeIterator nodeSet(object o) 
        {		
            if (o is XPathNavigator) 
            {
                XPathNavigator nav = (XPathNavigator)o;		        
                if (selectItself == null)
                    selectItself = nav.Compile(".");                                    
                return nav.Select(selectItself.Clone());
            } 
            else if (o is XPathNodeIterator)
                return o as XPathNodeIterator;
            else 
            {
                string s;
                if (o is string) 
                    s = o as string;
                else if (o is bool)
                    s = ((bool)o)? "true" : "false";
                else if (o is Double || o is Int16 || o is UInt16 || o is Int32
                    || o is UInt32 || o is Int64 || o is UInt64 || o is Single || o is Decimal)    
                    s = o.ToString();
                else    
                    return null;	
                //Now convert it to text node
                XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.None);                				    			
                XPathDocument doc = new XPathDocument(
                    new XmlTextReader("<d>"+s+"</d>", XmlNodeType.Element, context));				
                XPathNavigator nav = doc.CreateNavigator();                                         
                if (selectText == null)
                    selectText = nav.Compile("/d/text()");
                return nav.Select(selectText.Clone());
            }
        }

        /// <summary>
        /// Implements ParseXML
        /// </summary>
        /// <returns></returns>
        public IXmlResult ParseIATIXML(string url)
        {
            IXmlResult xmlResult;

            var serializer = new XmlSerializer(typeof(XmlResultv1), new XmlRootAttribute("result"));

            // Create an XmlNamespaceManager to resolve namespaces.
            NameTable nameTable = new NameTable();
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable);
            nsmgr.AddNamespace("iati-extra", "");

            // Create an XmlParserContext.  The XmlParserContext contains all the information
            // required to parse the XML fragment, including the entity information and the
            // XmlNamespaceManager to use for namespace resolution.
            XmlParserContext xmlParserContext = new XmlParserContext(nameTable, nsmgr, null, XmlSpace.None);

            // Create the reader.
            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
            xmlReaderSettings.NameTable = nameTable;

            using (var Reader = XmlReader.Create(url, xmlReaderSettings, xmlParserContext))
            {
                xmlResult = (XmlResultv1)serializer.Deserialize(Reader);
            }

            return xmlResult;
        }

        public static List<WPAuthor> ImportAuthors(string fileLocation)
        {
            try
            {
                var nsm = new XmlNamespaceManager(new NameTable());
                nsm.AddNamespace("wp", "http://wordpress.org/export/1.2/excerpt/");
                var parseContext = new XmlParserContext(null, nsm, null, XmlSpace.Default);

                using (var reader = XmlReader.Create(fileLocation, null, parseContext))
                {
                    var doc = XDocument.Load(reader);
                    string WordpressNamespace = "http://wordpress.org/export/1.2/";

                    XNamespace wpContent = WordpressNamespace;
                    List<WPAuthor> blogAuthors = new List<WPAuthor>();

                    foreach (XElement element in doc.Descendants("channel"))
                    {
                        foreach (XElement e in element.Descendants(wpContent + "author"))
                        {
                            WPAuthor auth = new WPAuthor(e);
                            blogAuthors.Add(auth);
                        }
                    }

                    return blogAuthors;
                }
            }
            catch (Exception ex)
            {
                Log.Error("Failed to import authors: " + ex.Message, "WP Importer");
                return new List<WPAuthor>();
            }
        }

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

 /// <summary>
 /// Constructs an <see cref="IContainerProfile"/>
 /// from a XML fragment.
 /// </summary>
 /// <param name="xmlContents"></param>
 /// <returns></returns>
 public virtual IContainerProfile Build(String xmlContents)
 {
     XmlNamespaceManager nsManager = new XmlNamespaceManager(new NameTable());
     XmlParserContext context = new XmlParserContext(null, nsManager, null, XmlSpace.None);
     XmlReader reader = new XmlTextReader(xmlContents, XmlNodeType.Element, context);
     return Build(reader);
 }

	public XmlValidatingReader(String xmlFragment, XmlNodeType fragType,
							   XmlParserContext context)
			{
				reader = new XmlTextReader(xmlFragment, fragType, context);
				entityHandling = EntityHandling.ExpandEntities;
				validationType = ValidationType.Auto;
				reader.Normalization = true;
			}

        static void Main(string[] args)
        {
            try
            {
                //XML fragment para validar
                string xmlFrag =
                 @"<address  myns:Pais='port' myns:PaisCode='351' xmlns='http://SD/PTAddress.xsd' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'  >" +
                    "<nome>ISEL</nome>" +
                    "<rua>Conselheiro Emidio Navarro</rua>" +
                    "<numero>1</numero>" + "<!-- comentario -->" +
                    "<numero>2</numero>" +
                    "<numero>3</numero>" +
                    "<numero>4</numero>" +
                    "<cidade>Lisboa</cidade>" +
                    "<codigo-postal>1950</codigo-postal>" +
                 "</address>";

                //Set the settings to xml reader and add the schema
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.Schemas.Add("http://SD/PTAddress.xsd", "..\\..\\XMLSchemaPTAddress.xsd");
                settings.ValidationType = ValidationType.Schema;
                settings.ValidationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes;
                settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings;
                settings.ConformanceLevel = ConformanceLevel.Fragment;
                settings.ValidationEventHandler += new ValidationEventHandler(ShowParserErrors);

                // Create the XmlNamespaceManager.
                XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
                nsmgr.AddNamespace("myns", "http://SD/PTAddress.xsd");

                // Create the XmlParserContext.
                XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);

                XmlReader reader = XmlReader.Create(new StringReader(xmlFrag), settings, context);

                while (reader.Read())
                {
                    //ler toda a string com fragmento xml
                }
                if (!erro) Console.WriteLine("XML fragment VÁLIDO");
            }
            catch (XmlException XmlExp)
            {
                Console.WriteLine(XmlExp.Message);
            }
            catch (XmlSchemaException XmlSchExp)
            {
                Console.WriteLine(XmlSchExp.Message);
            }
            catch (Exception GenExp)
            {
                Console.WriteLine(GenExp.Message);
            }
            finally
            {
                Console.Read();
            }
        }

		public EntityResolvingXmlReader (XmlReader source)
		{
			this.source = source;
			IHasXmlParserContext container = source as IHasXmlParserContext;
			if (container != null)
				this.context = container.ParserContext;
			else
				this.context = new XmlParserContext (source.NameTable, new XmlNamespaceManager (source.NameTable), null, XmlSpace.None);
		}

		public void Parse1 ()
		{
			XmlNamespaceManager nsMgr = new MyNS (XmlReader.Create (new StringReader (empty)));
			nsMgr.AddNamespace ("foo", "bar");
			XmlParserContext inputContext = new XmlParserContext (null, nsMgr, null, XmlSpace.None);

			XmlReader xr = XmlReader.Create (new StringReader (xmlstr), new XmlReaderSettings (), inputContext);
			while (xr.Read ()) {}
		}

 public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
 {
     if (xmlFragment == null)
     {
         throw new ArgumentNullException(nameof(xmlFragment));
     }
     _impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context);
     _impl.OuterReader = this;
 }

		/// <summary>
		/// An XML reader is needed to access the XML strings as nodes by the XmlDiff Compare method.
		/// </summary>
		/// <param name="xmlElement">An XML string that is a single element, most usefull when containing other nodes.</param>
		/// <returns>An XML reader for this string.</returns>
		private XmlReader StringToXmlReader(string xmlElement)
		{
			XmlNodeType fragType = XmlNodeType.Element;
			string xmlLang = "";
			System.Xml.XmlSpace xmlSpace = XmlSpace.None;
			XmlNameTable nt = new NameTable();
			System.Xml.XmlNamespaceManager nsMgr = new XmlNamespaceManager(nt);
			XmlParserContext context = new XmlParserContext(nt, nsMgr, xmlLang, xmlSpace);
			return new XmlTextReader(xmlElement, fragType, context);
		}

        public static XmlDocument ReadAddonXml(CarbonFile file)
        {
            var document = new XmlDocument();

            XmlParserContext context = new XmlParserContext(null, XmlNamespace, string.Empty, XmlSpace.Default);
            XmlReader reader = XmlReader.Create(file.GetPath(), XmlSettings, context);

            document.Load(reader);
            return document;
        }

        public Log4JParserForRemoteMessage(
            IRetrieveProcesses processRetriever,
            IHaveExtendedProperties extendedProperties)
        {
            Verify.NotNull(processRetriever, "processRetriever");
            Verify.NotNull(extendedProperties, "extendedProperties");

            this.xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
            this.xmlNamespaceManager.AddNamespace("log4j", "http://logging.apache.org/log4j/");
            this.xmlParserContext = new XmlParserContext(null, this.xmlNamespaceManager, null, XmlSpace.None);
        }

        internal static XmlParserContext CreateStrict()
        {
            XmlNameTable nameTable = new NameTable();
            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable);
            XmlParserContext context = new XmlParserContext(nameTable, namespaceManager, null, XmlSpace.None);

            context.DocTypeName = "html";
            context.PublicId = "-//W3C//DTD XHTML 1.0 Strict//EN";
            context.SystemId = "xhtml1-strict.dtd";
            return context;
        }

        protected XmlMessageParser(IRetrieveProcesses processRetriever, String namespacePrefix, String namespaceUri)
        {
            Verify.NotNull(processRetriever, "processRetriever");
            Verify.NotWhitespace(namespacePrefix, "namespacePrefix");
            Verify.NotWhitespace(namespaceUri, "namespaceUri");

            processes = processRetriever;
            xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
            xmlNamespaceManager.AddNamespace(namespacePrefix, namespaceUri);
            xmlParserContext = new XmlParserContext(null, xmlNamespaceManager, null, XmlSpace.None);
        }