public void XmlResolverWithFallbackAndKnownDtdsConstructor()
{
var fallbackResolver = new XmlPreloadedResolver();
var resolver = new XmlPreloadedResolver(fallbackResolver, XmlKnownDtds.Rss091);
string[] expectedUris = { "-//Netscape Communications//DTD RSS 0.91//EN", "http://my.netscape.com/publish/formats/rss-0.91.dtd" };
Assert.Equal(expectedUris.Length, resolver.PreloadedUris.Count());
foreach (string uriString in expectedUris)
{
Assert.Contains(resolver.PreloadedUris, u => u.OriginalString.Equals(uriString));
}
}
public void XmlResolverGetEntityAsyncWithValidUserSuppliedData()
{
byte[] inpData = Encoding.ASCII.GetBytes("hello world");
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
xmlResolver.Add(new Uri("-//W3C//DTD FAKE 1.0 Not Real//EN", UriKind.RelativeOrAbsolute), inpData);
Task <object> output = xmlResolver.GetEntityAsync(new Uri("-//W3C//DTD FAKE 1.0 Not Real//EN",
UriKind.RelativeOrAbsolute), null, typeof(Stream));
var result = new byte[inpData.Length];
(output.Result as Stream).Read(result, 0, result.Length);
Assert.Equal(inpData, result);
}
/// <summary>
/// Adds a byte array to the <see cref="XmlPreloadedResolver"/> store and maps it to a URI.
/// If the store already contains a mapping for the same URI,
/// the existing mapping is overridden if <paramref name="override"/> is specified as <see langword="true"/>.
/// </summary>
/// <param name="resolver">The resolver to which to add the data mapped to the URI.</param>
/// <param name="uri">The URI of the data that is being added to the <see cref="XmlPreloadedResolver"/> store.</param>
/// <param name="value">A byte array with the data that corresponds to the provided URI.</param>
/// <param name="override">
/// Whether to add <paramref name="value"/> and override the mapping for <paramref name="uri"/>
/// even if it is already defined in the store.
/// </param>
/// <returns>
/// <see langword="true"/> if <paramref name="value"/> was added to the store and mapped to <paramref name="uri"/>;
/// <see langword="false"/> if <paramref name="uri"/> was already defined and not overridden.
/// </returns>
/// <remarks>
/// Refer to the remarks on the <see cref="Add(XmlPreloadedResolver, Uri, Stream, bool)"/> overload.
/// </remarks>
public static bool Add(this XmlPreloadedResolver resolver, Uri uri, byte[] value, bool @override)
{
ArgumentValidate.NotNull(resolver, nameof(resolver));
ArgumentValidate.NotNull(uri, nameof(uri));
ArgumentValidate.NotNull(value, nameof(value));
if (@override || !resolver.PreloadedUris.Contains(uri))
{
resolver.Add(uri, value);
return(true);
}
return(false);
}
public void Add_NoOverride()
{
var uri = new Uri("http://test.local");
byte[] resourceA = new byte[] { 43, 59 };
byte[] resourceB = new byte[] { 217, 24, 64 };
var xmlResolver = new XmlPreloadedResolver();
xmlResolver.Add(uri, resourceA);
xmlResolver.Add(uri, resourceB, @override: false);
VerifyResource(resourceA, xmlResolver, uri);
}
public static XmlDocument CreateHtml5Document(XmlPreloadedResolver resolver)
{
XmlDocument resultDocument = new XmlDocument {
XmlResolver = resolver ?? new XmlPreloadedResolver(XmlKnownDtds.Xhtml10)
};
resultDocument.AppendChild(resultDocument.CreateDocumentType("html", "", EntityMapDictionary.DtdURI_Xhtml_Transitional, ""));
XmlElement xmlElement = ((XmlElement)resultDocument.AppendChild(resultDocument.CreateElement("html", NamespaceURI_Xhtml))).AppendElement("head");
xmlElement.AppendElement("meta").ApplyAttribute("name", "viewport").ApplyAttribute("content", "width=1024, initial-scale=1.0");
xmlElement.AppendElement("meta").ApplyAttribute("http-equiv", "X-UA-Compatible").ApplyAttribute("content", "utf-8");
xmlElement.AppendElement("meta").ApplyAttribute("charset", "ie=edge");
xmlElement.AppendElement("title").InnerText = "";
xmlElement = resultDocument.DocumentElement.AppendElement("body");
return(resultDocument);
}
/// <summary>
/// Initializes a new instance of the <see cref = "XmlPrimeSerializationTask" /> class.
/// </summary>
protected XmlPrimeSerializationTask()
{
// TODO: we should really be using ResourceResolvers rather than XmlResolvers (when we support them).
_nameTable = new NameTable();
var preloaded = new XmlPreloadedResolver(new XmlUrlResolver());
_xmlResolver = new GZipXmlUrlResolver(preloaded);
_schemaSet = new XmlSchemaSet(_nameTable)
{
XmlResolver = _xmlResolver
};
Validation = "none";
ProcessXsiSchemaLocation = true;
}
public void XmlResolverGetEntityAsyncWithInvalidData()
{
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
Assert.ThrowsAsync <ArgumentNullException>(() => xmlResolver.GetEntityAsync(null, null, null));
Assert.ThrowsAsync <XmlException>(() => xmlResolver.GetEntityAsync(new Uri("https://DummyUri"), null, null));
Assert.ThrowsAsync <XmlException>(() =>
xmlResolver.GetEntityAsync(new Uri("-//W3C//ENTITIES Latin 1 for XHTML//EN", UriKind.RelativeOrAbsolute), null, typeof(string)));
xmlResolver = new XmlPreloadedResolver(new XmlPreloadedResolver(), XmlKnownDtds.Xhtml10);
Assert.ThrowsAsync <XmlException>(() =>
xmlResolver.GetEntityAsync(new Uri("https://DummyUri", UriKind.RelativeOrAbsolute), null, typeof(string)));
Assert.ThrowsAsync <XmlException>(() =>
xmlResolver.GetEntityAsync(new Uri("-//W3C//ENTITIES Latin 1 for XHTML//EN", UriKind.RelativeOrAbsolute), null, typeof(TextReader)));
}
public void XmlResolverWithKnownDtdsXhtml10Constructor()
{
var resolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
string[] expectedUris = { "-//W3C//DTD XHTML 1.0 Strict//EN", "-//W3C//DTD XHTML 1.0 Transitional//EN",
"-//W3C//ENTITIES Symbols for XHTML//EN", "-//W3C//ENTITIES Latin 1 for XHTML//EN", "-//W3C//ENTITIES Symbols for XHTML//EN",
"-//W3C//ENTITIES Special for XHTML//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd",
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd",
"http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent", "http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent",
"http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent" };
Assert.Equal(expectedUris.Length, resolver.PreloadedUris.Count());
foreach (string uriString in expectedUris)
{
Assert.Contains(resolver.PreloadedUris, u => u.OriginalString.Equals(uriString));
}
}
public void XmlResolverGetEntityWithInvalidData()
{
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
Assert.Throws <XmlException>(() => xmlResolver.GetEntity(new Uri("https://JustAUri"), null, typeof(string)));
xmlResolver = new XmlPreloadedResolver(new XmlPreloadedResolver(), XmlKnownDtds.Xhtml10);
Assert.Throws <XmlException>(() => xmlResolver.GetEntity(new Uri("https://JustAUri"), null, typeof(string)));
xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
Assert.Throws <XmlException>(() => xmlResolver.GetEntity(new Uri("-//W3C//DTD XHTML 1.0 Transitional//EN", UriKind.RelativeOrAbsolute)
, null, typeof(string)));
xmlResolver = new XmlPreloadedResolver(new XmlPreloadedResolver(), XmlKnownDtds.Xhtml10);
Assert.Throws <XmlException>(() => xmlResolver.GetEntity(new Uri("-//W3C//Invalid URI ", UriKind.RelativeOrAbsolute)
, null, typeof(string)));
}
private static XmlReaderSettings GetXmlReaderSettings()
{
if (xmlReaderSettings == null)
{
var resolver = new XmlPreloadedResolver();
resolver.AddDTD("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd", "MergeWebToEpub.Resources.xhtml11-flat.dtd");
xmlReaderSettings = new XmlReaderSettings
{
DtdProcessing = DtdProcessing.Parse,
ValidationType = ValidationType.DTD,
XmlResolver = resolver,
};
xmlReaderSettings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
}
return(xmlReaderSettings);
}
public void XmlResolverSupportsTypeWithValidData()
{
var xmlResolver = new XmlPreloadedResolver();
var uri = new Uri("-//W3C//DTD XHTML 1.0 Strict//EN", UriKind.RelativeOrAbsolute);
bool result = xmlResolver.SupportsType(uri, typeof(string));
Assert.False(result);
xmlResolver = new XmlPreloadedResolver(new XmlPreloadedResolver(), XmlKnownDtds.Xhtml10);
Assert.True(xmlResolver.SupportsType(uri, typeof(Stream)));
xmlResolver.Add(uri, "String Value");
result = xmlResolver.SupportsType(uri, typeof(TextReader));
Assert.True(result);
result = xmlResolver.SupportsType(uri, null);
Assert.True(result);
}
public void XmlResolverWithFallbackResolverConstructor()
{
var fallbackResolver = new XmlPreloadedResolver(XmlKnownDtds.None);
var resolver = new XmlPreloadedResolver(fallbackResolver);
string[] expectedUris = { "-//W3C//DTD XHTML 1.0 Strict//EN", "-//W3C//DTD XHTML 1.0 Transitional//EN",
"-//W3C//ENTITIES Symbols for XHTML//EN", "-//W3C//ENTITIES Latin 1 for XHTML//EN", "-//W3C//ENTITIES Symbols for XHTML//EN",
"-//W3C//ENTITIES Special for XHTML//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd",
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd",
"http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent", "http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent",
"http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent", "-//Netscape Communications//DTD RSS 0.91//EN",
"http://my.netscape.com/publish/formats/rss-0.91.dtd" };
Assert.Equal(expectedUris.Length, resolver.PreloadedUris.Count());
foreach (string uriString in expectedUris)
{
Assert.Contains(resolver.PreloadedUris, u => u.OriginalString.Equals(uriString));
}
}
public void XmlResolverGetEntityWithValidUserSuppliedData()
{
var uri = new Uri("-//W3C//DTD FAKE 1.0 Not Real//EN", UriKind.RelativeOrAbsolute);
XmlPreloadedResolver xmlResolver =
GetResolverWithStringData(XmlKnownDtds.Xhtml10, "Sample String Data", uri);
Stream streamResult = xmlResolver.GetEntity(uri, null, null) as Stream;
Assert.NotNull(streamResult);
byte[] data = new byte[streamResult.Length];
streamResult.Read(data, 0, Convert.ToInt32(streamResult.Length));
Assert.Equal("Sample String Data", NormalizeContent(Encoding.ASCII.GetString(data)));
uri = new Uri("-//W3C//DTD FAKE 1.0 Not Real//EN", UriKind.RelativeOrAbsolute);
xmlResolver = GetResolverWithStringData(XmlKnownDtds.Xhtml10, "Sample String Data", uri);
TextReader textResult = xmlResolver.GetEntity(uri, null, typeof(TextReader)) as TextReader;
Assert.NotNull(textResult);
Assert.Equal("Sample String Data", textResult.ReadLine());
}
public void XmlResolverSupportsTypeWithInvalidData()
{
var xmlResolver = new XmlPreloadedResolver();
Assert.Throws <ArgumentNullException>(() => xmlResolver.SupportsType(null, null));
xmlResolver = new XmlPreloadedResolver();
var uri = new Uri("-//W3C//Dummy URI", UriKind.RelativeOrAbsolute);
bool result = xmlResolver.SupportsType(uri, null);
Assert.True(result);
result = xmlResolver.SupportsType(uri, typeof(string));
Assert.False(result);
xmlResolver = new XmlPreloadedResolver(new XmlPreloadedResolver());
result = xmlResolver.SupportsType(uri, typeof(string));
Assert.False(result);
}
public void Add_CustomComparer()
{
var uriA = new Uri("http://test.local/abc");
var uriB = new Uri("http://test.local/xyz");
var resourceA = new byte[] { 43, 59 };
var resourceB = new byte[] { 217, 24, 64 };
var uriComparer = KeyEqualityComparer.Create((Uri uri) => uri.Host);
var xmlResolver = new XmlPreloadedResolver(null, XmlKnownDtds.None, uriComparer);
xmlResolver.Add(uriA, resourceA);
xmlResolver.Add(uriB, resourceB, @override: false);
VerifyResource(resourceA, xmlResolver, uriA);
VerifyResource(resourceA, xmlResolver, uriB);
xmlResolver.Add(uriB, resourceB, @override: true);
VerifyResource(resourceB, xmlResolver, uriA);
VerifyResource(resourceB, xmlResolver, uriB);
}
public XSLTValidator(string languageName, XsltArgumentList xsltArgumentList)
{
if (null == xsltArgumentList)
{
throw new ArgumentNullException("xsltArgumentList");
}
_xslArg = xsltArgumentList;
_xslt = new XslCompiledTransform();
var assembly = this.GetType().Assembly;
var resolver = new XmlPreloadedResolver();
string mainXSLT = null;
string[] resourceNames = this.GetType().Assembly.GetManifestResourceNames();
foreach (string resourceName in resourceNames)
{
if (resourceName.EndsWith(".xslt") && resourceName.Contains(languageName))
{
string templateName = resourceName.Substring(resourceName.LastIndexOf(languageName) + languageName.Length);
if (templateName == ".xslt")
{
mainXSLT = resourceName;
}
else
{
using (var stream = assembly.GetManifestResourceStream(resourceName))
{
resolver.Add(resolver.ResolveUri(null, templateName), stream);
}
}
}
}
using (var stream = assembly.GetManifestResourceStream(mainXSLT))
using (var reader = XmlReader.Create(stream))
{
_xslt.Load(reader, null, resolver);
}
}
public void AddXhtml11_XDocument()
{
var xmlResolver = new XmlPreloadedResolver();
xmlResolver.AddXhtml11();
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Parse;
settings.XmlResolver = xmlResolver;
XDocument document;
using (var stringReader = new StringReader(sampleXhtml))
using (var xmlReader = XmlReader.Create(stringReader, settings))
document = XDocument.Load(xmlReader);
XNamespace ns = "http://www.w3.org/1999/xhtml";
var span = document.Descendants(ns + "span").Single();
Assert.AreEqual(" ®µ½Σ", span.Value);
}
public void XmlResolverGetKnownEntity()
{
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.All);
foreach (var dtdInfo in GetKnownDtds())
{
string expectedContent = NormalizeContent(File.ReadAllText(dtdInfo.SourcePath));
var uri = new Uri(dtdInfo.PublicId, UriKind.RelativeOrAbsolute);
Stream streamResult = xmlResolver.GetEntity(uri, null, null) as Stream;
Assert.NotNull(streamResult);
byte[] data = new byte[streamResult.Length];
streamResult.Read(data, 0, Convert.ToInt32(streamResult.Length));
Assert.Equal(expectedContent, NormalizeContent(Encoding.ASCII.GetString(data)));
uri = new Uri(dtdInfo.SystemId, UriKind.RelativeOrAbsolute);
streamResult = xmlResolver.GetEntity(uri, null, null) as Stream;
Assert.NotNull(streamResult);
data = new byte[streamResult.Length];
streamResult.Read(data, 0, Convert.ToInt32(streamResult.Length));
Assert.Equal(expectedContent, NormalizeContent(Encoding.ASCII.GetString(data)));
}
}
public void XmlResolverAddWithInvalidData()
{
var xmlResolver = new XmlPreloadedResolver();
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(null, new byte[22]));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(new Uri("https://html"), null as byte[]));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(null, null, 0, 0));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(new Uri("https://html"), null, 0, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => xmlResolver.Add(new Uri("https://html"), new byte[22], -1, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => xmlResolver.Add(new Uri("https://html"), new byte[22], 0, -1));
Assert.Throws <ArgumentOutOfRangeException>(() => xmlResolver.Add(new Uri("https://html"), new byte[11], 5, 20));
//No Exception should be thrown for the below cases as these are border cases
xmlResolver.Add(new Uri("https://html"), new byte[0], 0, 0);
xmlResolver.Add(new Uri("https://html"), new byte[5], 0, 5);
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(null, new MemoryStream()));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(new Uri("https://html"), null as MemoryStream));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(null, string.Empty));
Assert.Throws <ArgumentNullException>(() => xmlResolver.Add(new Uri("https://html"), null as string));
}
protected override void Render(HtmlTextWriter writer)
{
StringBuilder sbOut = new StringBuilder();
StringWriter swOut = new StringWriter(sbOut);
HtmlTextWriter htwOut = new HtmlTextWriter(swOut);
base.Render(htwOut);
string originalHTML = sbOut.ToString();
if ("true".Equals(Context.Items["EmailRequest"]))
{
XmlDocument document = new XmlDocument();
string xhtmlStr = sbOut.ToString();
XmlPreloadedResolver resolver = new XmlPreloadedResolver();
resolver.Add(resolver.ResolveUri(null, "Static/xhtml-trans10.dtd"), xhtmlStr);
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.XmlResolver = resolver;
readerSettings.DtdProcessing = DtdProcessing.Parse;
StringReader sr = new StringReader(xhtmlStr);
XmlReader reader = XmlReader.Create(sr, readerSettings);
document.Load(reader);
XmlElement root = document.DocumentElement;
XmlNamespaceManager nsmgr = new XmlNamespaceManager(document.NameTable);
nsmgr.AddNamespace("h", document.DocumentElement.NamespaceURI);
RewriteImageURLs(root.SelectNodes("//h:img", nsmgr));
RewriteCSSPaths(root.SelectNodes("//h:link", nsmgr));
TransformNodes(document, root.SelectNodes("//h:a", nsmgr), "span");
DeleteNodes(root.SelectNodes("//h:div[@id='inventory-graph']", nsmgr));
DeleteNodes(root.SelectNodes("//h:div[@id='chart']", nsmgr));
DeleteNodes(root.SelectNodes("//h:script", nsmgr));
DeleteNodes(root.SelectNodes("//h:input[@type='hidden']", nsmgr));
// this bit of xpath gets all elements that have onclick attributes
RemoveOnClickEvents(root.SelectNodes("self::node()/descendant-or-self::node()[@onclick]", nsmgr));
string reportHTML =
"<!DOCTYPE html PUBLIC \" -//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
reportHTML += document.DocumentElement.OuterXml;
_message.Body += "<br/>" + reportHTML;
if (Context.Items["EmailAttachmentName"].ToString().EndsWith("pdf"))
{
PdfService service = new PdfService();
byte[] pdf = service.GeneratePdf(reportHTML);
_message.Attachments.Add(new Attachment(new MemoryStream(pdf),
Context.Items["EmailAttachmentName"].ToString()));
}
else if (Context.Items["EmailAttachmentName"].ToString().EndsWith("html"))
{
ASCIIEncoding encoder = new ASCIIEncoding();
_message.Attachments.Add(new Attachment(new MemoryStream(encoder.GetBytes(reportHTML)),
Context.Items["EmailAttachmentName"].ToString()));
}
SmtpClient client = new SmtpClient();
client.Send(_message);
}
writer.Write(originalHTML);
}
public void XmlResolverResolveUriWithEmptyUri()
{
var resolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
Assert.Throws <ArgumentNullException>(() => resolver.ResolveUri(null, null));
}
public static void AddXhtml11(this XmlPreloadedResolver resolver, bool @override = false)
{
Add(resolver, new Uri(Xhtml11DtdPublicId, UriKind.RelativeOrAbsolute), ManifestResources.xhtml11_flat_dtd, @override);
Add(resolver, new Uri(Xhtml11DtdSystemId, UriKind.RelativeOrAbsolute), ManifestResources.xhtml11_flat_dtd, @override);
}
public void XmlResolverGetEntityWithNullUri()
{
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.None);
Assert.Throws <ArgumentNullException>(() => xmlResolver.GetEntity(null, null, null));
}
public void XmlResolverWithDefaultConstructor()
{
var resolver = new XmlPreloadedResolver();
Assert.Equal(14, resolver.PreloadedUris.Count());
}
public void XmlResolverRemoveWithInvalidData()
{
var xmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);
Assert.Throws <ArgumentNullException>(() => xmlResolver.Remove(null));
}
