//[Ignore("XInclude migration in progress.")]
public void FullLoad()
{
XIncludingReader ir = new XIncludingReader(new XmlTextReader(BaseDir + "mainconfig.xml"));
// Dump for debugging purposes.
XmlTextWriter tw = new XmlTextWriter(Console.Out);
tw.WriteNode(ir, false);
ir = new XIncludingReader(new XmlTextReader(BaseDir + "mainconfig.xml"));
XmlSerializer ser = new GuidancePackageSerializer();
GuidancePackage package = (GuidancePackage)ser.Deserialize(ir);
// Check included recipe
Assert.AreEqual("ReusableRecipe", package.Recipes[0].Name);
// Check included types in included recipe
Assert.AreEqual("Page", package.Recipes[0].Types[1].Name);
// Check included wizard
Assert.IsNotNull(package.Recipes[0].GatheringServiceData);
XmlSerializer wzser = new XmlSerializer(typeof(Wizard));
Wizard wz = (Wizard)wzser.Deserialize(new XmlNodeReader(package.Recipes[0].GatheringServiceData.Any));
Assert.AreEqual("ExistingWizard", wz.Name);
}
public void testURLInvocation_XInclude_XIncludingReader()
{
// reset the counter
WebRequest request = WebRequest.Create("http://127.0.0.1:5000/reset");
WebResponse response = request.GetResponse();
String filename = "C:/Christopher_Spaeth/code/xml_files_windows/ssrf/url_invocation_xinclude.xml";
XmlReaderSettings settings = new XmlReaderSettings();
XmlReader reader = XmlReader.Create(filename, settings);
//XmlDocument xmlDoc = new XmlDocument();
//xmlDoc.Load(reader);
//XmlReader r = XmlReader.Create(filename);
XIncludingReader xir = new XIncludingReader(reader);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xir);
String content = xmlDoc.DocumentElement.InnerText;
//check the counter
request = WebRequest.Create("http://127.0.0.1:5000/getCounter");
response = request.GetResponse();
Stream dataStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(dataStream);
string responseServer = streamReader.ReadToEnd();
responseServer = responseServer.Trim();
Assert.AreEqual("1", responseServer);
}
static void Load(String inputFile)
{
Console.WriteLine("Probing " + Path.GetFileName(inputFile));
String outputFile = Path.ChangeExtension(inputFile, ".xml");
using (XIncludingReader reader = new XIncludingReader(inputFile)) {
using (StreamWriter writer = new StreamWriter(outputFile)) {
XmlDocument doc = new XmlDocument();
doc.Load(reader);
// Remove "xml:base attribute"
RemoveXmlBase(doc.DocumentElement);
doc.Save(writer);
XDocument doc2 = ToXDocument(doc);
Console.WriteLine(doc2.Elements().Count());
//dictionary dictionary = new dictionary(doc2.Root);
//Console.WriteLine (dictionary.title);
}
}
using (StreamReader reader = new StreamReader(outputFile)) {
XmlSerializer serializer = new XmlSerializer(typeof(dictionary));
dictionary dict = (dictionary)serializer.Deserialize(reader);
Console.WriteLine(dict.title);
}
}
public void TestXPointerIndentationBug()
{
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XsltSettings xsltSettings = new XsltSettings();
xsltSettings.EnableDocumentFunction = true;
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
XmlReader reader = XmlReader.Create("../../XInclude/tests/Transform.xsl", settings);
XIncludingReader xInputReader = new XIncludingReader("../../XInclude/tests/FileA.xml");
try
{
MvpXslTransform processor = new MvpXslTransform(false);
processor.Load(reader, xsltSettings, resolver);
//xInputReader.XmlResolver = new XMLBase();
XmlDocument xInputDoc = new XmlDocument();
xInputDoc.Load(xInputReader);
XmlInput xInput = new XmlInput(xInputDoc);
StringWriter stringW = new StringWriter();
XmlOutput xOutput = new XmlOutput(stringW);
processor.Transform(xInput, null, xOutput);
processor.TemporaryFiles.Delete();
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?>NodeA Content", stringW.ToString());
}
finally
{
reader.Close();
xInputReader.Close();
}
}
/// <summary>
/// Generates a wrapper.
/// </summary>
/// <param name = "prefix">The prefix.</param>
/// <param name = "inputFile">The input file.</param>
public void Generate(String prefix, String inputFile)
{
String outputFile = prefix + "." + this.Extension;
String workingFile = Path.ChangeExtension(inputFile, ".xml");
if (!File.Exists(inputFile))
{
throw new ArgumentException("Input file not found: " + inputFile);
}
// Use a XInclude compliant parser to load all the inclusions
Console.WriteLine("Processing '" + inputFile + "' ...");
using (XIncludingReader reader = new XIncludingReader(inputFile))
{
// Load the definition file
// All the XInclude extensions will be unfolded
XmlDocument doc = new XmlDocument();
doc.Load(reader);
// Remove "xml:base attribute"
// This cause error when using XmlSerializer
RemoveXmlBase(doc.DocumentElement);
doc.Save(workingFile);
// Convert the document to a Linq compatible object
XDocument xDoc = ToXDocument(doc);
// Output the code
using (TextWriter writer = new StreamWriter(outputFile))
{
this.Generate(prefix, xDoc, writer);
}
}
}
public void ShouldPreserveCDATA()
{
string xml = "<HTML><![CDATA[<img src=\"/_layouts/images/\">]]></HTML>";
XIncludingReader xir = new XIncludingReader(new StringReader(xml));
xir.Read();
Assert.AreEqual("<HTML><![CDATA[<img src=\"/_layouts/images/\">]]></HTML>", xir.ReadOuterXml());
}
//[Ignore("XmlSerialization doesn't work on dynamic AppDomains")]
public void RecipeLoad()
{
XIncludingReader ir = new XIncludingReader(new XmlTextReader(BaseDir + "recipe.xml"));
XmlSerializer ser = new XmlSerializer(typeof(Recipe));
Recipe rec = (Recipe)ser.Deserialize(ir);
// Two types should have been included.
Assert.AreEqual(2, rec.Types.Length);
}
public void EncodingTest()
{
XmlTextReader r = new XmlTextReader(new StringReader("<foo/>"));
XIncludingReader xir = new XIncludingReader(r);
xir.ExposeTextInclusionsAsCDATA = true;
xir.MoveToContent();
Assert.IsTrue(xir.Encoding == UnicodeEncoding.Unicode);
}
public void UnknownParseAttribute()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/unknownparseattr.xml");
while (xir.Read())
{
;
}
xir.Close();
}
public void FallbackNotChildOfInclude()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/fallbacknotchildinclude.xml");
while (xir.Read())
{
;
}
xir.Close();
}
public void IncludeChildOfInclude()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/includechildofinclude.xml");
while (xir.Read())
{
;
}
xir.Close();
}
public void TwoFallbacks()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/twofallbacks.xml");
while (xir.Read())
{
;
}
xir.Close();
}
public void NoHrefAndNoXPointerAttributes()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/nohref.xml");
while (xir.Read())
{
;
}
xir.Close();
}
/// <summary>
/// Loads mapping from the embedded resource with particular name.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
private static ITextMapping LoadMapping(string name)
{
using (var reader = new XIncludingReader(name + ".xml", xmlResolver))
{
/// Setting the resolver here according to http://mvp-xml.sourceforge.net/xinclude/#mozTocId795134
/// Passing as a parameter is also required to resolve the original file
reader.XmlResolver = xmlResolver;
return(CreateMapping(XElement.Load(reader)));
}
}
public static XmlReader CreateReader(string filename, XmlReaderSettings settings, NXsltOptions options, XmlResolver resolver)
{
if (options.ProcessXInclude)
{
XIncludingReader xir = new XIncludingReader(filename, (resolver != null && resolver is DTDAllowingResolver)? new XmlUrlResolver() : resolver);
xir.XmlResolver = resolver;
return(XmlReader.Create(xir, settings));
}
else
{
return(XmlReader.Create(filename, settings));
}
}
public static XmlReader CreateReader(Stream stream, XmlReaderSettings settings, NXsltOptions options, XmlResolver resolver)
{
if (options.ProcessXInclude)
{
XIncludingReader xir = new XIncludingReader(Directory.GetCurrentDirectory(), stream, resolver);
xir.XmlResolver = resolver;
return(XmlReader.Create(xir, settings));
}
else
{
return(XmlReader.Create(stream, settings));
}
}
private static XmlReader ResolveXInclude(string configfile)
{
XIncludingReader xir = new XIncludingReader(configfile);
MemoryStream mem = new MemoryStream();
XmlWriter writer = XmlWriter.Create(mem);
writer.WriteNode(xir, false);
writer.Flush();
mem.Position = 0;
new XmlReaderSettings();
return(new FixedBaseURIWrappingReader(XmlReader.Create(mem), configfile));
}
public void NoBaseURITest()
{
StreamReader sr = new StreamReader("../../XInclude/tests/document.xml");
string xml = sr.ReadToEnd();
sr.Close();
XIncludingReader xir = new XIncludingReader(new StringReader(xml));
XmlTextWriter w = new XmlTextWriter(Console.Out);
while (xir.Read())
{
;
}
}
public override async Task <Message> HandleMessage(Message msg)
{
XmlReader reader;
if (msg is XMLMessage)
{
reader = ((XMLMessage)msg).GetReader();
}
else if (msg is IStreamMessage)
{
reader = XmlReader.Create(await((IStreamMessage)msg).GetStream());
}
else if (msg is IStringMessage)
{
reader = XmlReader.Create(new StringReader(((IStringMessage)msg).Value));
}
else
{
return(null);
}
return(await Task.Run <Message>(() =>
{
try
{
// Chain XmlReaders together to handle XIncludes, plugins
// and macro expansion.
// A pipeline within a pipeline within a pipeline.
XIncludingReader includingReader = new XIncludingReader(reader);
XPluginReader pluginReader = new XPluginReader(includingReader);
XDownstreamReader downstreamReader = new XDownstreamReader(pluginReader);
XUpstreamReader upstreamReader = new XUpstreamReader(downstreamReader);
var deserialiser = new XMeeplangDeserialiser();
var tree = deserialiser.Deserialise(upstreamReader);
return new DeserialisedPipeline
{
DerivedFrom = msg,
Tree = tree
};
}
catch (Exception ex)
{
logger.Error(ex, "{0} thrown when deserialising pipeline definition: {1}", ex.GetType().Name, ex.Message);
return null;
}
}));
}
public void SerializerTest()
{
XmlSerializer ser = new XmlSerializer(typeof(Document));
using (XIncludingReader r = new XIncludingReader("../../XInclude/tests/Document3.xml"))
{
Document doc = (Document)ser.Deserialize(r);
Assert.IsNotNull(doc);
Assert.IsTrue(doc.Name == "Foo");
Assert.IsNotNull(doc.Items);
Assert.IsTrue(doc.Items.Length == 1);
Assert.IsTrue(doc.Items[0].Value == "Bar");
}
}
public void GetAttributeTest()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/document.xml");
while (xir.Read())
{
if (xir.NodeType == XmlNodeType.Element && xir.Name == "disclaimer")
{
Assert.IsTrue(xir.AttributeCount == 1);
Assert.IsTrue(xir.GetAttribute(0).EndsWith("disclaimer.xml"));
Assert.IsTrue(xir[0].EndsWith("disclaimer.xml"));
}
}
}
public void DepthTest()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/document.xml");
StringBuilder sb = new StringBuilder();
while (xir.Read())
{
Console.WriteLine("{0} | {1} | {2} | {3}",
xir.NodeType, xir.Name, xir.Value, xir.Depth);
sb.Append(xir.Depth);
}
string expected = "00011211111111223221100";
Assert.AreEqual(sb.ToString(), expected);
}
public void GetAttributeTest2()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/document2.xml");
xir.MakeRelativeBaseUri = false;
while (xir.Read())
{
if (xir.NodeType == XmlNodeType.Element && xir.Name == "disclaimer")
{
Assert.IsTrue(xir.AttributeCount == 1);
Assert.IsTrue(xir.GetAttribute(0).EndsWith("tests/disclaimerWithXmlBase.xml"));
Assert.IsTrue(xir[0].EndsWith("tests/disclaimerWithXmlBase.xml"));
}
}
}
public void LoadNoValidateOrInclusions()
{
XIncludingReader ir = new XIncludingReader(new XmlTextReader(BaseDir + "smallconfig.xml"));
XmlReaderSettings validateReaderSettings = new XmlReaderSettings();
// Add the schema to validate against.
validateReaderSettings.ValidationType = ValidationType.Schema;
validateReaderSettings.Schemas.Add("http://schemas.microsoft.com/pag/gax-core", "GuidancePackageConfig.xsd");
XmlReader vr = XmlReader.Create(ir, validateReaderSettings);
// Deserialize with validating reader.
XmlSerializer ser = new GuidancePackageSerializer();
GuidancePackage package = (GuidancePackage)ser.Deserialize(vr);
// Done!
}
private static void ParseListOfFiles(string path)
{
var reader = new XIncludingReader(XmlReader.Create(path));
var document = XDocument.Load(reader);
var files = document.Root;
var scriptElements = files.Elements(Script.TAGNAME);
foreach (var scriptElement in scriptElements)
{
Script.Load(scriptElement, scriptElements);
}
}
//[Ignore("XmlSerialization doesn't work on dynamic AppDomains")]
public void WizardLoad()
{
XIncludingReader ir = new XIncludingReader(BaseDir + "wizard.xml");
ir.MoveToContent();
Console.WriteLine(ir.ReadOuterXml());
ir = new XIncludingReader(BaseDir + "wizard.xml");
XmlSerializer ser = new XmlSerializer(typeof(Wizard));
Wizard wz = (Wizard)ser.Deserialize(ir);
ir.Close();
Assert.IsNotNull(wz.Types);
Assert.AreEqual(2, wz.Types.Length);
}
public void Load(string fileName)
{
string schema = Path.GetDirectoryName(Application.ExecutablePath) + @"\Templates\config.xsd";
if (System.IO.File.Exists(schema))
{
XmlTextReader r = new XmlTextReader(fileName);
XIncludingReader xir = new XIncludingReader(r);
this.doc.Schemas.Add(null, schema);
this.doc.Load(xir);
//this.doc.Validate(null/*this.ValidationEventHandler*/);
}
else
{
throw new System.IO.FileNotFoundException("Файл config.xsd не найден. Продолжение не возможно.", schema);
}
}
public MockConfigurationService(string file)
{
MemoryStream mem = new MemoryStream();
XIncludingReader xir = new XIncludingReader(file);
XmlWriter writer = XmlWriter.Create(mem);
writer.WriteNode(xir, false);
writer.Flush();
mem.Position = 0;
XmlReader reader = XmlReader.Create(mem);
configuration = (Configuration.GuidancePackage)
new Configuration.Serialization.GuidancePackageSerializer().Deserialize(reader);
this.metaData = new Hashtable();
}
public void InnerXmlTest()
{
XIncludingReader xir = new XIncludingReader("../../XInclude/tests/document.xml");
xir.MoveToContent();
string innerXml = xir.ReadInnerXml();
xir.Close();
xir = new XIncludingReader("../../XInclude/tests/document.xml");
xir.MoveToContent();
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
doc.Load(xir);
string innerXml2 = doc.DocumentElement.InnerXml;
Assert.AreEqual(innerXml, innerXml2);
}
private static XmlReader ResolveXInclude(XmlReader configReader)
{
// Wrap reader in including reader to enable XInclude.
if (!(configReader is XIncludingReader))
{
// Temporarily render included file because of
// an error in deserialization otherwise.
MemoryStream mem = new MemoryStream();
XIncludingReader xir = new XIncludingReader(configReader);
XmlWriter writer = XmlWriter.Create(mem);
writer.WriteNode(xir, false);
writer.Flush();
mem.Position = 0;
return(new FixedBaseURIWrappingReader(XmlReader.Create(mem), configReader.BaseURI));
}
return(configReader);
}
public static void Main()
{
//String filename = "C:/Christopher_Spaeth/code/xml_files_windows/standard.xml";
//XmlReader reader = XmlReader.Create(filename);
//reader.ReadToFollowing("data");
//String content = reader.ReadElementContentAsString();
//Console.Write(content);
//Console.ReadKey();
String filename = "C:/Christopher_Spaeth/code/xml_files_windows/xinclude.xml";
//XmlTextReader r = new XmlTextReader(filename);
XmlReaderSettings settings = new XmlReaderSettings();
//XmlReader reader = XmlReader.Create(filename, settings);
//XIncludingReader xir = new XIncludingReader(r);
XmlReader reader = XmlReader.Create(filename, settings);
XIncludingReader xincludingReader = new XIncludingReader(reader);
XmlReader reader2 = XmlReader.Create(xincludingReader, settings);
reader2.ReadToFollowing("data");
String content = reader2.ReadInnerXml();
Console.Write(content);
Console.ReadKey();
//XmlReaderSettings settings = new XmlReaderSettings();
//settings.DtdProcessing = DtdProcessing.Parse;
// as documented in https://msdn.microsoft.com/en-us/library/system.xml.xmlreadersettings.validationtype%28v=vs.110%29.aspx
// ValidationFlag ProcessSchemaLocation has to set
//settings.ValidationFlags = XmlSchemaValidationFlags.ProcessSchemaLocation;
//settings.ValidationType = ValidationType.Schema;
//XmlReader reader = XmlReader.Create(filename, settings);
//reader.ReadToFollowing("data", "http://test.com/attack");
// XInclude works conveniently with XmlDocument, but not with XMLReader
//XmlTextReader r = new XmlTextReader(filename);
//XIncludingReader xir = new XIncludingReader(r);
////XmlDocument doc = new XmlDocument();
////doc.Load(xir);
////String content = doc.DocumentElement.InnerText;
//xir.ReadToFollowing("data");
//Console.Write(xir.ReadInnerXml());
//Console.ReadKey();
// string markup =
//@"<!DOCTYPE Root [
// <!ENTITY anEntity ""Expands to more than 30 characters"">
// <!ELEMENT Root (#PCDATA)>
//]>
//<Root>Content &anEntity;</Root>";
//XmlReaderSettings settings = new XmlReaderSettings();
//settings.DtdProcessing = DtdProcessing.Parse;
//settings.ValidationType = ValidationType.DTD;
//settings.MaxCharactersFromEntities = 30;
// try
// {
// XmlReader reader = XmlReader.Create(new StringReader(markup), settings);
// while (reader.Read()) { }
// }
// catch (XmlException ex)
// {
// Console.WriteLine(ex.Message);
// Console.ReadKey();
// }
//XmlTextReader textReader = new XmlTextReader(filename);
//XmlReaderSettings settings = new XmlReaderSettings();
//settings.ProhibitDtd = false;
//XmlReader reader = XmlReader.Create(filename, settings);
// XmlReader reader = XmlReader.Create(filename);
//reader.ReadToFollowing("data");
//String content = reader.ReadElementContentAsString();
//Console.WriteLine(content);
//Console.ReadKey();
}
/// <summary>
/// Perform the transformation.
/// </summary>
/// <param name="inputFile">Input (XML) file.</param>
/// <param name="xsltFile">Transformation (XSLT) file.</param>
/// <param name="outputFile">Output file.</param>
private void Transform(string inputFile, string xsltFile, string outputFile)
{
try
{
XIncludingReader xIncludingReader = new XIncludingReader(inputFile);
XPathDocument xPathDocument = new XPathDocument(xIncludingReader);
XslCompiledTransform xslTransform = new XslCompiledTransform(true);
xslTransform.Load(xsltFile);
System.IO.StreamWriter streamWriter = new StreamWriter(outputFile, false, System.Text.Encoding.ASCII);
xslTransform.Transform(xPathDocument, new XsltArgumentList(), streamWriter);
xIncludingReader.Close();
streamWriter.Close();
}
catch (Exception exception)
{
// Add error handling here.
MessageBox.Show(this, exception.Message, "Error", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
return;
}
}
public void testURLInvocation_XInclude_XIncludingReader()
{
// reset the counter
WebRequest request = WebRequest.Create("http://127.0.0.1:5000/reset");
WebResponse response = request.GetResponse();
String filename = "C:/Christopher_Spaeth/code/xml_files_windows/url_invocation_xinclude.xml";
XmlReaderSettings settings = new XmlReaderSettings();
XmlReader reader = XmlReader.Create(filename, settings);
//XmlDocument xmlDoc = new XmlDocument();
//xmlDoc.Load(reader);
//XmlReader r = XmlReader.Create(filename);
XIncludingReader xir = new XIncludingReader(reader);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xir);
String content = xmlDoc.DocumentElement.InnerText;
//check the counter
request = WebRequest.Create("http://127.0.0.1:5000/getCounter");
response = request.GetResponse();
Stream dataStream = response.GetResponseStream();
StreamReader streamReader = new StreamReader(dataStream);
string responseServer = streamReader.ReadToEnd();
responseServer = responseServer.Trim();
Assert.AreEqual("1", responseServer);
}
public void testXInclude_XIncludingReader()
{
String filename = "C:/Christopher_Spaeth/code/xml_files_windows/xinclude.xml";
XmlReaderSettings settings = new XmlReaderSettings();
XmlReader reader = XmlReader.Create(filename, settings);
XIncludingReader xir = new XIncludingReader(reader);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xir);
String content = xmlDoc.DocumentElement.InnerText;
//String content = xmlDoc.DocumentElement.InnerText;
String childElement = xmlDoc.DocumentElement.FirstChild.Name;
Assert.AreEqual("content", childElement);
String childContent = xmlDoc.DocumentElement.FirstChild.InnerText;
Assert.AreEqual("it_works", childContent);
}
