public override int Init(object objParam)
{
baselinePath1 = Path.Combine(FilePathUtil.GetTestDataPath(), @"XmlWriter2\");
string temp = FilePathUtil.GetVariableValue("WriterType").ToUpperInvariant();
switch (temp)
{
case "UTF8WRITER":
writerType1 = WriterType.UTF8Writer;
break;
case "UNICODEWRITER":
writerType1 = WriterType.UnicodeWriter;
break;
case "CUSTOMWRITER":
writerType1 = WriterType.CustomWriter;
break;
case "UTF8WRITERINDENT":
writerType1 = WriterType.UTF8WriterIndent;
break;
case "UNICODEWRITERINDENT":
writerType1 = WriterType.UnicodeWriterIndent;
break;
case "CHARCHECKINGWRITER":
writerType1 = WriterType.CharCheckingWriter;
break;
case "WRAPPEDWRITER":
writerType1 = WriterType.WrappedWriter;
break;
default:
throw new Exception("Unknown writer type: " + temp);
}
writerFactory1 = new XmlCoreTest.Common.WriterFactory(writerType1);
return(base.Init(objParam));
}
public void CloseOutput_3(XmlWriterUtils utils, string outputType)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
wSettings.CloseOutput = true;
XmlWriter w = null;
switch (utils.WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
break;
}
Stream writerStream = FilePathUtil.getStream("writer.out");
switch (outputType)
{
case "Stream":
w = WriterHelper.Create(writerStream, wSettings, overrideAsync: true, async: utils.Async);
break;
case "Textwriter":
StreamWriter tw = new StreamWriter(writerStream, wSettings.Encoding);
w = WriterHelper.Create(tw, wSettings, overrideAsync: true, async: utils.Async);
break;
}
w.WriteStartElement("root");
w.WriteEndElement();
w.Dispose();
if (writerStream.CanWrite)
{
writerStream.Dispose();
Assert.True(false);
}
}
public static void CreateBigElementTestFile(string strFileName)
{
var s = new MemoryStream();
using var tw = new StreamWriter(s, encoding: null, bufferSize: -1, leaveOpen: true);
string str = new string('Z', (1 << 20) - 1);
tw.WriteLine("<Root>");
tw.Write("<");
tw.Write(str);
tw.WriteLine("X />");
tw.Write("<");
tw.Write(str);
tw.WriteLine("Y />");
tw.WriteLine("</Root>");
FilePathUtil.addStream(strFileName, s);
}
public int SkipAfterReadAttributeValueAndReadValueChunkDoesNotThrow()
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.DtdProcessing = DtdProcessing.Ignore;
XmlReader reader = XmlReader.Create(FilePathUtil.getStream(this.StandardPath + @"\XML10\ms_xml\vs084.xml"), settings);
reader.ReadToFollowing("a");
reader.MoveToNextAttribute();
reader.ReadAttributeValue();
reader.ReadValueChunk(new char[3], 0, 3); //<< removing this line works fine.
reader.Skip();
CError.Compare(reader.NodeType, XmlNodeType.Whitespace, "NT");
reader.Read();
CError.Compare(reader.NodeType, XmlNodeType.Element, "NT1");
CError.Compare(reader.Name, "a", "Name");
return(TEST_PASS);
}
public static void CreateNamespaceTestFile(string strFileName)
{
Stream s = new MemoryStream();
TextWriter tw = new StreamWriter(s);
tw.WriteLine("<DOCNAMESPACE>");
tw.WriteLine("<NAMESPACE0 xmlns:bar=\"1\"><bar:check>Namespace=1</bar:check></NAMESPACE0>");
tw.WriteLine("<NAMESPACE1 xmlns:bar=\"1\"><a><b><c><d><bar:check>Namespace=1</bar:check></d></c></b></a></NAMESPACE1>");
tw.WriteLine("<NONAMESPACE>Namespace=\"\"</NONAMESPACE>");
tw.WriteLine("<EMPTY_NAMESPACE bar:Attr0=\"0\" xmlns:bar=\"1\" />");
tw.WriteLine("<EMPTY_NAMESPACE1 Attr0=\"0\" xmlns=\"14\" />");
tw.WriteLine("<NAMESPACE2 xmlns:bar=\"1\"><a><b><c xmlns:bar=\"2\"><d><bar:check>Namespace=2</bar:check></d></c></b></a></NAMESPACE2>");
tw.WriteLine("<NAMESPACE3 xmlns=\"1\"><a xmlns:a=\"2\" xmlns:b=\"3\" xmlns:c=\"4\"><b xmlns:d=\"5\" xmlns:e=\"6\" xmlns:f='7'><c xmlns:d=\"8\" xmlns:e=\"9\" xmlns:f=\"10\">");
tw.WriteLine("<d xmlns:g=\"11\" xmlns:h=\"12\"><check>Namespace=1</check><testns xmlns=\"100\"><check100>Namespace=100</check100></testns><check1>Namespace=1</check1><d:check8>Namespace=8</d:check8></d></c><d:check5>Namespace=5</d:check5></b></a>");
tw.WriteLine("<a13 a:check=\"Namespace=13\" xmlns:a=\"13\" /><check14 xmlns=\"14\">Namespace=14</check14></NAMESPACE3>");
tw.WriteLine("<NONAMESPACE>Namespace=\"\"</NONAMESPACE>");
tw.WriteLine("</DOCNAMESPACE>");
tw.Flush();
FilePathUtil.addStream(strFileName, s);
}
//[Variation("ReadBinHex runs into an Overflow", Params = new object[] { "1000000" })]
//[Variation("ReadBinHex runs into an Overflow", Params = new object[] { "10000000" })]
public int TestReadBinHex_105376()
{
int totalfilesize = Convert.ToInt32(CurVariation.Params[0].ToString());
CError.WriteLine(" totalfilesize = " + totalfilesize);
string ascii = new string('c', totalfilesize);
byte[] bits = Encoding.Unicode.GetBytes(ascii);
CError.WriteLineIgnore("Count = " + bits.Length);
string base64str = Convert.ToBase64String(bits);
string fileName = "bug105376c_" + CurVariation.Params[0].ToString() + ".xml";
MemoryStream mems = new MemoryStream();
StreamWriter sw = new StreamWriter(mems);
sw.Write("<root><base64>");
sw.Write(base64str);
sw.Write("</base64></root>");
sw.Flush();//sw.Close();
FilePathUtil.addStream(fileName, mems);
ReloadSource(fileName);
int SIZE = (totalfilesize - 30);
int SIZE64 = SIZE * 3 / 4;
DataReader.PositionOnElement("base64");
if (CheckCanReadBinaryContent())
{
return(TEST_PASS);
}
byte[] base64 = new byte[SIZE64];
try
{
DataReader.ReadElementContentAsBinHex(base64, 0, 4096);
return(TEST_FAIL);
}
catch (XmlException) { DataReader.Close(); return(TEST_PASS); }
finally { DataReader.Close(); }
}
public void CloseOutput_2(XmlWriterUtils utils, bool closeOutput)
{
XmlWriterSettings wSettings = new XmlWriterSettings();
switch (utils.WriterType)
{
case WriterType.UTF8Writer:
wSettings.Encoding = Encoding.UTF8;
break;
case WriterType.UnicodeWriter:
wSettings.Encoding = Encoding.Unicode;
break;
}
wSettings.CloseOutput = closeOutput;
XmlWriter w = WriterHelper.Create("writer.out", wSettings, overrideAsync: true, async: utils.Async);
w.WriteStartElement("root");
w.WriteEndElement();
w.Dispose();
// Check if you can open the file in ReadWrite mode
Stream fs = null;
try
{
fs = FilePathUtil.getStream("writer.out");/*new FileStream("writer.out", FileMode.Open, FileAccess.ReadWrite);*/
}
catch (Exception e)
{
CError.WriteLineIgnore("Exception: " + e.ToString());
CError.WriteLine("Uri stream is not closed by writer");
Assert.True(false);
}
finally
{
fs.Dispose();
}
return;
}
static XsltApiTestCaseBase()
{
// In AppContainer access is denied to full path and the code below and related tests cannot run
if (!PlatformDetection.IsInAppContainer)
{
string testDirPath = Path.Combine(FilePathUtil.GetWriteableTestRootPath(), "TestFiles", FilePathUtil.GetTestDataPath(), "XsltApi");
Directory.CreateDirectory(Path.GetDirectoryName(s_temporaryResolverDocumentFullName));
Directory.CreateDirectory(testDirPath);
// Replace absolute URI in xmlResolver_document_function.xml based on the environment, and store it under a different name
string xslFile = Path.Combine("TestFiles", FilePathUtil.GetTestDataPath(), "XsltApi", "xmlResolver_document_function_absolute_uri.xsl");
absoluteUriXslFile = Path.Combine(testDirPath, "xmlResolver_document_function_absolute_uri_replaced.xsl");
File.Copy(xslFile, absoluteUriXslFile, true);
XmlDocument doc = new XmlDocument();
doc.Load(absoluteUriXslFile);
string xslString = doc.OuterXml.Replace("ABSOLUTE_URI", s_temporaryResolverDocumentFullName);
doc.LoadXml(xslString);
doc.Save(absoluteUriXslFile);
}
}
public static void CreateBigElementTestFile(string strFileName)
{
MemoryStream ms = new MemoryStream();
TextWriter tw = new StreamWriter(ms);
string str = new String('Z', (1 << 20) - 1);
tw.WriteLine("<Root>");
tw.Write("<");
tw.Write(str);
tw.WriteLine("X />");
tw.Flush();
tw.Write("<");
tw.Write(str);
tw.WriteLine("Y />");
tw.WriteLine("</Root>");
tw.Flush();
FilePathUtil.addStream(strFileName, ms);
}
public int LineNumberAndLinePositionAreCorrect()
{
XmlReaderSettings rs = new XmlReaderSettings();
Stream fs = FilePathUtil.getStream(TestData + "Common\\Bug297091.xsl");
{
XmlReader DataReader = ReaderHelper.Create(fs, rs, TestData + "Common\\Bug297091.xsl");
DataReader.Read();
if (DataReader.NodeType != XmlNodeType.Element || ((IXmlLineInfo)DataReader).LineNumber != 1 || ((IXmlLineInfo)DataReader).LinePosition != 2)
{
CError.Compare(false, "Failed");
}
DataReader.Read();
if (DataReader.NodeType != XmlNodeType.Whitespace || ((IXmlLineInfo)DataReader).LineNumber != 4 || ((IXmlLineInfo)DataReader).LinePosition != 2)
{
CError.Compare(false, "Failed");
}
DataReader.Read();
if (DataReader.NodeType != XmlNodeType.Element || ((IXmlLineInfo)DataReader).LineNumber != 5 || ((IXmlLineInfo)DataReader).LinePosition != 3)
{
CError.Compare(false, "Failed");
}
DataReader.Read();
if (DataReader.NodeType != XmlNodeType.Whitespace || ((IXmlLineInfo)DataReader).LineNumber != 5 || ((IXmlLineInfo)DataReader).LinePosition != 28)
{
CError.Compare(false, "Failed");
}
DataReader.Read();
if (DataReader.NodeType != XmlNodeType.EndElement || ((IXmlLineInfo)DataReader).LineNumber != 6 || ((IXmlLineInfo)DataReader).LinePosition != 3)
{
CError.Compare(false, "Failed");
}
}
return(TEST_PASS);
}
public override int Init(object objParam)
{
int ret = base.Init(objParam);
// These steps use to be part of javascript files and these were copied and executed as test setup step.
// I belive this to be a much better way of accomplishing the same task.
// Logic from CreateApiTestFiles.js
string sourceFile = Path.Combine(FilePathUtil.GetTestDataPath(), @"XsltApiV2\xmlResolver_document_function.xml");
string targetFile = @"c:\temp\xmlResolver_document_function.xml";
if (!Directory.Exists(@"c:\temp"))
Directory.CreateDirectory(@"c:\temp");
if (!File.Exists(targetFile))
File.Copy(sourceFile, targetFile, true);
// Logic from CreateStrasse.js
using (XmlWriter writer = XmlWriter.Create("Stra\u00DFe.xml"))
{
writer.WriteComment(" ");
}
return ret;
}
public /*override*/ new void Init(object objParam)
{
xsltSameInstance = new XslCompiledTransform();
_strPath = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltApiV2\");
return;
}
public override XmlReader Create(MyDict <string, object> options)
{
string tcDesc = (string)options[ReaderFactory.HT_CURDESC];
string tcVar = (string)options[ReaderFactory.HT_CURVAR];
CError.Compare(tcDesc == "subtreereader", "Invalid testcase");
XmlReaderSettings rs = (XmlReaderSettings)options[ReaderFactory.HT_READERSETTINGS];
Stream stream = (Stream)options[ReaderFactory.HT_STREAM];
string filename = (string)options[ReaderFactory.HT_FILENAME];
object readerType = options[ReaderFactory.HT_READERTYPE];
object vt = options[ReaderFactory.HT_VALIDATIONTYPE];
string fragment = (string)options[ReaderFactory.HT_FRAGMENT];
StringReader sr = (StringReader)options[ReaderFactory.HT_STRINGREADER];
if (rs == null)
{
rs = new XmlReaderSettings();
}
rs.DtdProcessing = DtdProcessing.Ignore;
if (sr != null)
{
CError.WriteLine("SubtreeReader String");
XmlReader r = ReaderHelper.Create(sr, rs, string.Empty);
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
break;
}
}
XmlReader wr = r.ReadSubtree();
return(wr);
}
if (stream != null)
{
CError.WriteLine("SubtreeReader Stream");
XmlReader r = ReaderHelper.Create(stream, rs, filename);
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
break;
}
}
XmlReader wr = r.ReadSubtree();
return(wr);
}
if (fragment != null)
{
CError.WriteLine("SubtreeReader Fragment");
rs.ConformanceLevel = ConformanceLevel.Fragment;
StringReader tr = new StringReader(fragment);
XmlReader r = ReaderHelper.Create(tr, rs, (string)null);
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
break;
}
}
XmlReader wr = r.ReadSubtree();
return(wr);
}
if (filename != null)
{
CError.WriteLine("SubtreeReader Filename");
Stream fs = FilePathUtil.getStream(filename);
XmlReader r = ReaderHelper.Create(fs, rs, filename);
while (r.Read())
{
if (r.NodeType == XmlNodeType.Element)
{
break;
}
}
XmlReader wr = r.ReadSubtree();
return(wr);
}
throw new CTestFailedException("SubtreeReader not created");
}
/// <summary>
/// This method will test the read based on different settings.
/// It will call the correct overload and set the state properly.
/// </summary>
protected override void Test()
{
CError.WriteLine("Testing : " + TestFileName);
string tempStr = null;
switch (_overload)
{
case ReaderOverload.StreamReader:
_textReader = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
CreateReader(ReadThru.TextReader);
break;
case ReaderOverload.StringReader:
StreamReader sr = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
tempStr = sr.ReadToEnd();
sr.Dispose();
_textReader = new StringReader(tempStr);
CreateReader(ReadThru.TextReader);
break;
case ReaderOverload.FileStream:
_stream = FilePathUtil.getStream(TestFileName);
CreateReader(ReadThru.Stream);
break;
case ReaderOverload.MemoryStream:
StreamReader sr1 = new StreamReader(FilePathUtil.getStream(GetFile(TestFileName)));
tempStr = sr1.ReadToEnd();
sr1.Dispose();
byte[] bits = _enc.GetBytes(tempStr);
_stream = new MemoryStream(bits);
CreateReader(ReadThru.Stream);
break;
case ReaderOverload.CoreReader:
_underlyingSettings.DtdProcessing = DtdProcessing.Ignore;
_underlyingSettings.ConformanceLevel = _settings.ConformanceLevel;
StringReader strr = new StringReader(new StreamReader(FilePathUtil.getStream(GetFile(TestFileName))).ReadToEnd());
_underlyingReader = ReaderHelper.CreateReader(_overload.ToString(),
strr,
false,
null,
_underlyingSettings,
(_settings.ConformanceLevel == ConformanceLevel.Fragment)); //should this be settings or underlyingSettings?
CError.Compare(_underlyingReader != null, "ReaderHelper returned null Reader");
CreateReader(ReadThru.XmlReader);
break;
case ReaderOverload.CustomReader:
if (AsyncUtil.IsAsyncEnabled)
{
pstate = TestState.Skip;
return;
}
if (_settings.ConformanceLevel != ConformanceLevel.Fragment)
{
_underlyingReader = new CustomReader(FilePathUtil.getStream(GetFile(TestFileName)), false);
}
else
{
_underlyingReader = new CustomReader(FilePathUtil.getStream(GetFile(TestFileName)), true);
}
CError.Compare(_underlyingReader != null, "ReaderHelper returned null Reader");
CreateReader(ReadThru.XmlReader);
break;
default:
throw new CTestFailedException("Unknown ReaderOverload: " + _overload);
}
if (_underlyingReader != null)
{
CError.WriteLineIgnore("Type of Reader : " + _underlyingReader.GetType());
}
if (pstate == TestState.Pass)
{
return;
}
CError.Compare(pstate, TestState.CreateSuccess, "Invalid State after Create: " + pstate);
//By this time the factory Reader is already set up correctly. So we must go Consume it now.
CError.Compare(pstate != TestState.Pass && pstate == TestState.CreateSuccess, "Invalid state before Consuming Reader: " + pstate);
//Call TestReader to Consume Reader;
TestReader();
if (pstate == TestState.Pass)
{
return;
}
CError.Compare(pstate != TestState.Pass && pstate == TestState.Consume, "Invalid state after Consuming Reader: " + pstate);
}
public static void CreateBinHexTestFile(string strFileName)
{
byte[] Wbinhex = new byte[2000];
int Wbinhexlen = 0;
byte[] WNumOnly = new byte[2000];
int WNumOnlylen = 0;
byte[] WTextOnly = new byte[2000];
int WTextOnlylen = 0;
int i = 0;
for (i = 0; i < strBinHex.Length; i++)
{
WriteToBuffer(ref Wbinhex, ref Wbinhexlen, System.BitConverter.GetBytes(strBinHex[i]));
}
for (i = 0; i < 10; i++)
{
WriteToBuffer(ref WNumOnly, ref WNumOnlylen, System.BitConverter.GetBytes(strBinHex[i]));
}
for (i = 10; i < strBinHex.Length; i++)
{
WriteToBuffer(ref WTextOnly, ref WTextOnlylen, System.BitConverter.GetBytes(strBinHex[i]));
}
var mems = new MemoryStream();
using var w = XmlWriter.Create(mems, new XmlWriterSettings { CloseOutput = false });
w.WriteStartElement("Root");
w.WriteStartElement("ElemAll");
w.WriteBinHex(Wbinhex, 0, (int)Wbinhexlen);
w.WriteEndElement();
w.WriteStartElement("ElemEmpty");
w.WriteString(string.Empty);
w.WriteEndElement();
w.WriteStartElement("ElemNum");
w.WriteBinHex(WNumOnly, 0, (int)WNumOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemText");
w.WriteBinHex(WTextOnly, 0, (int)WTextOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemNumText");
w.WriteBinHex(WNumOnly, 0, (int)WNumOnlylen);
w.WriteBinHex(WTextOnly, 0, (int)WTextOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemLong");
for (i = 0; i < 10; i++)
{
w.WriteBinHex(Wbinhex, 0, (int)Wbinhexlen);
}
w.WriteEndElement();
w.WriteElementString("ElemErr", "a&A2A3");
w.WriteEndElement();
FilePathUtil.addStream(strFileName, mems);
}
public static void CreateBase64TestFile(string strFileName)
{
byte[] Wbase64 = new byte[2048];
int Wbase64len = 0;
byte[] WNumOnly = new byte[1024];
int WNumOnlylen = 0;
byte[] WTextOnly = new byte[1024];
int WTextOnlylen = 0;
int i = 0;
for (i = 0; i < strBase64.Length; i++)
{
WriteToBuffer(ref Wbase64, ref Wbase64len, System.BitConverter.GetBytes(strBase64[i]));
}
for (i = 52; i < strBase64.Length; i++)
{
WriteToBuffer(ref WNumOnly, ref WNumOnlylen, System.BitConverter.GetBytes(strBase64[i]));
}
for (i = 0; i < strBase64.Length - 12; i++)
{
WriteToBuffer(ref WTextOnly, ref WTextOnlylen, System.BitConverter.GetBytes(strBase64[i]));
}
var mems = new MemoryStream();
using var w = XmlWriter.Create(mems, new XmlWriterSettings { CloseOutput = false });
w.WriteStartDocument();
w.WriteStartElement("Root");
w.WriteStartElement("ElemAll");
w.WriteBase64(Wbase64, 0, (int)Wbase64len);
w.WriteEndElement();
w.WriteStartElement("ElemEmpty");
w.WriteString(string.Empty);
w.WriteEndElement();
w.WriteStartElement("ElemNum");
w.WriteBase64(WNumOnly, 0, (int)WNumOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemText");
w.WriteBase64(WTextOnly, 0, (int)WTextOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemNumText");
w.WriteBase64(WTextOnly, 0, (int)WTextOnlylen);
w.WriteBase64(WNumOnly, 0, (int)WNumOnlylen);
w.WriteEndElement();
w.WriteStartElement("ElemLong");
for (i = 0; i < 10; i++)
{
w.WriteBase64(Wbase64, 0, (int)Wbase64len);
}
w.WriteEndElement();
w.WriteElementString("ElemErr", "a&AQID");
w.WriteStartElement("ElemMixed");
w.WriteRaw("D2BAa<MIX></MIX>AQID");
w.WriteEndElement();
w.WriteEndElement();
FilePathUtil.addStream(strFileName, mems);
}
public new void Init(object objParam)
{
xsltSameInstance = new XslCompiledTransform();
_strPath = Path.Combine("TestFiles", FilePathUtil.GetTestDataPath(), "XsltApiV2");
return;
}
public Stream GetStream()
{
return(FilePathUtil.getStream(_sampleFileName));
}
public void RunEXslTest(object param0, object param1, object param2, object param3, object param4)
{
string OutFile = "out_exslt.xml";
string xmlFile = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltScenarios\EXslt\", param0.ToString());
string xslFile = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltScenarios\EXslt\", param1.ToString());
string resultType = param2.ToString();
string baseLine = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltScenarios\EXslt\out\", param3.ToString());
#pragma warning disable 0618
if (param4.ToString() == "v1")
{
_xsltV1 = new XslTransform();
}
#pragma warning restore 0618
else if (param4.ToString() == "v2")
{
_xsltV2 = new XslCompiledTransform();
}
Utils util = new Utils(_output);
_output.WriteLine("XmlFile : file:\\\\" + xmlFile);
_output.WriteLine("XslFile : file:\\\\" + xslFile);
if (resultType == "valid")
{
_output.WriteLine("BaseLine : file:\\\\" + baseLine);
}
else
{
_output.WriteLine("Test Type : Invalid");
}
//Create the argument list and load the source document
XsltArgumentList argList = InitArgumentList();
XPathDocument doc = null;
try
{
doc = new XPathDocument(xmlFile);
}
catch (Exception e)
{
_output.WriteLine(e.ToString());
Assert.True(false);
}
//Delete the output file if it exists
using (Stream stm = new FileStream(OutFile, FileMode.Create, FileAccess.ReadWrite))
{
try
{
if (param4.ToString() == "v1")
{
XPathDocument xslDoc = new XPathDocument(xslFile);
//Evidence evidence = new Evidence();
//evidence.AddHost(new Zone(SecurityZone.MyComputer));
//evidence.AddHost(new Zone(SecurityZone.Intranet));
_xsltV1.Load(xslDoc, new XmlUrlResolver() /*, evidence*/);
_xsltV1.Transform(doc, argList, stm, new XmlUrlResolver());
}
else if (param4.ToString() == "v2")
{
_xsltV2.Load(xslFile, XsltSettings.TrustedXslt, new XmlUrlResolver());
_xsltV2.Transform(doc, argList, stm);
}
stm.Dispose();
util.VerifyResult(OutFile, baseLine);
}
//For V1 Transform
catch (XPathException ex)
{
_output.WriteLine(ex.Message);
if (resultType == "invalid")
{
return;
}
else
{
Assert.True(false);
}
}
//For V2 Transform
catch (XsltException ex)
{
_output.WriteLine(ex.Message);
if (resultType == "invalid")
{
return;
}
else
{
Assert.True(false);
}
}
}
}
public override XmlReader Create(MyDict <string, object> options)
{
string tcDesc = (string)options[ReaderFactory.HT_CURDESC];
string tcVar = (string)options[ReaderFactory.HT_CURVAR];
CError.Compare(tcDesc == "charcheckingreader", "Invalid testcase");
XmlReaderSettings rs = (XmlReaderSettings)options[ReaderFactory.HT_READERSETTINGS];
Stream stream = (Stream)options[ReaderFactory.HT_STREAM];
string filename = (string)options[ReaderFactory.HT_FILENAME];
object readerType = options[ReaderFactory.HT_READERTYPE];
object vt = options[ReaderFactory.HT_VALIDATIONTYPE];
string fragment = (string)options[ReaderFactory.HT_FRAGMENT];
StringReader sr = (StringReader)options[ReaderFactory.HT_STRINGREADER];
if (rs == null)
{
rs = new XmlReaderSettings();
}
rs.DtdProcessing = DtdProcessing.Ignore;
rs.CheckCharacters = false;
XmlReaderSettings wrs = new XmlReaderSettings();
wrs.DtdProcessing = DtdProcessing.Ignore;
wrs.CheckCharacters = true;
wrs.ConformanceLevel = ConformanceLevel.Auto;
if (sr != null)
{
CError.WriteLine("CharCheckingReader String");
XmlReader r = ReaderHelper.Create(sr, rs, string.Empty);
XmlReader wr = ReaderHelper.Create(r, wrs);
return(wr);
}
if (stream != null)
{
CError.WriteLine("CharCheckingReader Stream");
XmlReader r = ReaderHelper.Create(stream, rs, filename);
XmlReader wr = ReaderHelper.Create(r, wrs);
return(wr);
}
if (fragment != null)
{
CError.WriteLine("CharCheckingReader Fragment");
rs.ConformanceLevel = ConformanceLevel.Fragment;
StringReader tr = new StringReader(fragment);
XmlReader r = ReaderHelper.Create(tr, rs, (string)null);
XmlReader wr = ReaderHelper.Create(r, wrs);
return(wr);
}
if (filename != null)
{
CError.WriteLine("CharCheckingReader Filename");
Stream fs = FilePathUtil.getStream(filename);
XmlReader r = ReaderHelper.Create(fs, rs, filename);
XmlReader wr = ReaderHelper.Create(r, wrs);
return(wr);
}
return(null);
}
public static void CreateGenericTestFile(string strFileName)
{
MemoryStream ms = new MemoryStream();
TextWriter tw = new StreamWriter(ms);
tw.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>");
tw.WriteLine("<!-- comment1 -->");
tw.WriteLine("<?PI1_First processing instruction?>");
tw.WriteLine("<?PI1a?>");
tw.WriteLine("<?PI1b?>");
tw.WriteLine("<?PI1c?>");
tw.WriteLine("<!DOCTYPE root SYSTEM \"AllNodeTypes.dtd\" [");
tw.WriteLine("<!NOTATION gif SYSTEM \"foo.exe\">");
tw.WriteLine("<!ELEMENT root ANY>");
tw.WriteLine("<!ELEMENT elem1 ANY>");
tw.WriteLine("<!ELEMENT ISDEFAULT ANY>");
tw.WriteLine("<!ENTITY % e SYSTEM \"AllNodeTypes.ent\">");
tw.WriteLine("%e;");
tw.WriteLine("<!ENTITY e1 \"e1foo\">");
tw.WriteLine("<!ENTITY e2 \"&ext3; e2bar\">");
tw.WriteLine("<!ENTITY e3 \"&e1; e3bzee \">");
tw.WriteLine("<!ENTITY e4 \"&e3; e4gee\">");
tw.WriteLine("<!ATTLIST elem1 child1 CDATA #IMPLIED child2 CDATA \"&e2;\" child3 CDATA #REQUIRED>");
tw.WriteLine("<!ATTLIST root xmlns:something CDATA #FIXED \"something\" xmlns:my CDATA #FIXED \"my\" xmlns:dt CDATA #FIXED \"urn:uuid:C2F41010-65B3-11d1-A29F-00AA00C14882/\">");
tw.WriteLine("<!ATTLIST ISDEFAULT d1 CDATA #FIXED \"d1value\">");
tw.WriteLine("<!ATTLIST MULTISPACES att IDREFS #IMPLIED>");
tw.WriteLine("<!ELEMENT CATMIXED (#PCDATA)>");
tw.WriteLine("]>");
tw.WriteLine("<PLAY>");
tw.WriteLine("<root xmlns:something=\"something\" xmlns:my=\"my\" xmlns:dt=\"urn:uuid:C2F41010-65B3-11d1-A29F-00AA00C14882/\">");
tw.WriteLine("<elem1 child1=\"\" child2=\"e1foo e3bzee e2bar\" child3=\"something\">");
tw.WriteLine("text node two e1foo text node three");
tw.WriteLine("</elem1>");
tw.WriteLine("e1foo e3bzee e2bar");
tw.WriteLine("<![CDATA[ This section contains characters that should not be interpreted as markup. For example, characters ', \",");
tw.WriteLine("<, >, and & are all fine here.]]>");
tw.WriteLine("<elem2 att1=\"id1\" att2=\"up\" att3=\"attribute3\"> ");
tw.WriteLine("<a />");
tw.WriteLine("</elem2>");
tw.WriteLine("<elem2> ");
tw.WriteLine("elem2-text1");
tw.WriteLine("<a refs=\"id2\"> ");
tw.WriteLine("this-is-a ");
tw.WriteLine("</a> ");
tw.WriteLine("elem2-text2");
tw.WriteLine("e1foo e3bzee ");
tw.WriteLine("e1foo e3bzee e4gee");
tw.WriteLine("<!-- elem2-comment1-->");
tw.WriteLine("elem2-text3");
tw.WriteLine("<b> ");
tw.WriteLine("this-is-b");
tw.WriteLine("</b>");
tw.WriteLine("elem2-text4");
tw.WriteLine("<?elem2_PI elem2-PI?>");
tw.WriteLine("elem2-text5");
tw.WriteLine("</elem2>");
tw.WriteLine("<elem2 att1=\"id2\"></elem2>");
tw.WriteLine("</root>");
tw.Write("<ENTITY1 att1='xxx<xxxAxxxCxxxe1fooxxx'>xxx>xxxBxxxDxxxe1fooxxx</ENTITY1>");
tw.WriteLine("<ENTITY2 att1='xxx<xxxAxxxCxxxe1fooxxx'>xxx>xxxBxxxDxxxe1fooxxx</ENTITY2>");
tw.WriteLine("<ENTITY3 att1='xxx<xxxAxxxCxxxe1fooxxx'>xxx>xxxBxxxDxxxe1fooxxx</ENTITY3>");
tw.WriteLine("<ENTITY4 att1='xxx<xxxAxxxCxxxe1fooxxx'>xxx>xxxBxxxDxxxe1fooxxx</ENTITY4>");
tw.WriteLine("<ENTITY5>e1foo e3bzee </ENTITY5>");
tw.WriteLine("<ATTRIBUTE1 />");
tw.WriteLine("<ATTRIBUTE2 a1='a1value' />");
tw.WriteLine("<ATTRIBUTE3 a1='a1value' a2='a2value' a3='a3value' />");
tw.WriteLine("<ATTRIBUTE4 a1='' />");
tw.WriteLine("<ATTRIBUTE5 CRLF='x\r\nx' CR='x\rx' LF='x\nx' MS='x x' TAB='x\tx' />");
tw.WriteLine("<ENDOFLINE1>x\r\nx</ENDOFLINE1>");
tw.WriteLine("<ENDOFLINE2>x\rx</ENDOFLINE2>");
tw.WriteLine("<ENDOFLINE3>x\nx</ENDOFLINE3>");
tw.WriteLine("<WHITESPACE1>\r\n<ELEM />\r\n</WHITESPACE1>");
tw.WriteLine("<WHITESPACE2> <ELEM /> </WHITESPACE2>");
tw.WriteLine("<WHITESPACE3>\t<ELEM />\t</WHITESPACE3>");
tw.WriteLine("<SKIP1 /><AFTERSKIP1 />");
tw.WriteLine("<SKIP2></SKIP2><AFTERSKIP2 />");
tw.WriteLine("<SKIP3><ELEM1 /><ELEM2>xxx yyy</ELEM2><ELEM3 /></SKIP3><AFTERSKIP3></AFTERSKIP3>");
tw.WriteLine("<SKIP4><ELEM1 /><ELEM2>xxx<ELEM3 /></ELEM2></SKIP4>");
tw.WriteLine("<CHARS1>0123456789</CHARS1>");
tw.WriteLine("<CHARS2>xxx<MARKUP />yyy</CHARS2>");
tw.WriteLine("<CHARS_ELEM1>xxx<MARKUP />yyy</CHARS_ELEM1>");
tw.WriteLine("<CHARS_ELEM2><MARKUP />yyy</CHARS_ELEM2>");
tw.WriteLine("<CHARS_ELEM3>xxx<MARKUP /></CHARS_ELEM3>");
tw.WriteLine("<CHARS_CDATA1>xxx<![CDATA[yyy]]>zzz</CHARS_CDATA1>");
tw.WriteLine("<CHARS_CDATA2><![CDATA[yyy]]>zzz</CHARS_CDATA2>");
tw.WriteLine("<CHARS_CDATA3>xxx<![CDATA[yyy]]></CHARS_CDATA3>");
tw.WriteLine("<CHARS_PI1>xxx<?PI_CHAR1 yyy?>zzz</CHARS_PI1>");
tw.WriteLine("<CHARS_PI2><?PI_CHAR2?>zzz</CHARS_PI2>");
tw.WriteLine("<CHARS_PI3>xxx<?PI_CHAR3 yyy?></CHARS_PI3>");
tw.WriteLine("<CHARS_COMMENT1>xxx<!-- comment1-->zzz</CHARS_COMMENT1>");
tw.WriteLine("<CHARS_COMMENT2><!-- comment1-->zzz</CHARS_COMMENT2>");
tw.WriteLine("<CHARS_COMMENT3>xxx<!-- comment1--></CHARS_COMMENT3>");
tw.Flush();
tw.WriteLine("<ISDEFAULT />");
tw.WriteLine("<ISDEFAULT a1='a1value' />");
tw.WriteLine("<BOOLEAN1>true</BOOLEAN1>");
tw.WriteLine("<BOOLEAN2>false</BOOLEAN2>");
tw.WriteLine("<BOOLEAN3>1</BOOLEAN3>");
tw.WriteLine("<BOOLEAN4>tRue</BOOLEAN4>");
tw.WriteLine("<DATETIME>1999-02-22T11:11:11</DATETIME>");
tw.WriteLine("<DATE>1999-02-22</DATE>");
tw.WriteLine("<TIME>11:11:11</TIME>");
tw.WriteLine("<INTEGER>9999</INTEGER>");
tw.WriteLine("<FLOAT>99.99</FLOAT>");
tw.WriteLine("<DECIMAL>.09</DECIMAL>");
tw.WriteLine("<CONTENT><e1 a1='a1value' a2='a2value'><e2 a1='a1value' a2='a2value'><e3 a1='a1value' a2='a2value'>leave</e3></e2></e1></CONTENT>");
tw.WriteLine("<TITLE><!-- this is a comment--></TITLE>");
tw.WriteLine("<PGROUP>");
tw.WriteLine("<ACT0 xmlns:foo=\"http://www.foo.com\" foo:Attr0=\"0\" foo:Attr1=\"1111111101\" foo:Attr2=\"222222202\" foo:Attr3=\"333333303\" foo:Attr4=\"444444404\" foo:Attr5=\"555555505\" foo:Attr6=\"666666606\" foo:Attr7=\"777777707\" foo:Attr8=\"888888808\" foo:Attr9=\"999999909\" />");
tw.WriteLine("<ACT1 Attr0=\'0\' Attr1=\'1111111101\' Attr2=\'222222202\' Attr3=\'333333303\' Attr4=\'444444404\' Attr5=\'555555505\' Attr6=\'666666606\' Attr7=\'777777707\' Attr8=\'888888808\' Attr9=\'999999909\' />");
tw.WriteLine("<QUOTE1 Attr0=\"0\" Attr1=\'1111111101\' Attr2=\"222222202\" Attr3=\'333333303\' />");
tw.WriteLine("<PERSONA>DROMIO OF EPHESUS</PERSONA>");
tw.WriteLine("<QUOTE2 Attr0=\"0\" Attr1=\"1111111101\" Attr2=\'222222202\' Attr3=\'333333303\' />");
tw.WriteLine("<QUOTE3 Attr0=\'0\' Attr1=\"1111111101\" Attr2=\'222222202\' Attr3=\"333333303\" />");
tw.WriteLine("<EMPTY1 />");
tw.WriteLine("<EMPTY2 val=\"abc\" />");
tw.WriteLine("<EMPTY3></EMPTY3>");
tw.WriteLine("<NONEMPTY0></NONEMPTY0>");
tw.WriteLine("<NONEMPTY1>ABCDE</NONEMPTY1>");
tw.WriteLine("<NONEMPTY2 val=\"abc\">1234</NONEMPTY2>");
tw.WriteLine("<ACT2 Attr0=\"10\" Attr1=\"1111111011\" Attr2=\"222222012\" Attr3=\"333333013\" Attr4=\"444444014\" Attr5=\"555555015\" Attr6=\"666666016\" Attr7=\"777777017\" Attr8=\"888888018\" Attr9=\"999999019\" />");
tw.WriteLine("<GRPDESCR>twin brothers, and sons to Aegeon and Aemilia.</GRPDESCR>");
tw.WriteLine("</PGROUP>");
tw.WriteLine("<PGROUP>");
tw.Flush();
tw.WriteLine("<XMLLANG0 xml:lang=\"en-US\">What color e1foo is it?</XMLLANG0>");
tw.Write("<XMLLANG1 xml:lang=\"en-GB\">What color is it?<a><b><c>Language Test</c><PERSONA>DROMIO OF EPHESUS</PERSONA></b></a></XMLLANG1>");
tw.WriteLine("<NOXMLLANG />");
tw.WriteLine("<EMPTY_XMLLANG Attr0=\"0\" xml:lang=\"en-US\" />");
tw.WriteLine("<XMLLANG2 xml:lang=\"en-US\">What color is it?<TITLE><!-- this is a comment--></TITLE><XMLLANG1 xml:lang=\"en-GB\">Testing language<XMLLANG0 xml:lang=\"en-US\">What color is it?</XMLLANG0>haha </XMLLANG1>hihihi</XMLLANG2>");
tw.WriteLine("<DONEXMLLANG />");
tw.WriteLine("<XMLSPACE1 xml:space=\'default\'>< ></XMLSPACE1>");
tw.Write("<XMLSPACE2 xml:space=\'preserve\'>< ><a><!-- comment--><b><?PI1a?><c>Space Test</c><PERSONA>DROMIO OF SYRACUSE</PERSONA></b></a></XMLSPACE2>");
tw.WriteLine("<NOSPACE />");
tw.WriteLine("<EMPTY_XMLSPACE Attr0=\"0\" xml:space=\'default\' />");
tw.WriteLine("<XMLSPACE2A xml:space=\'default\'>< <XMLSPACE3 xml:space=\'preserve\'> < > <XMLSPACE4 xml:space=\'default\'> < > </XMLSPACE4> test </XMLSPACE3> ></XMLSPACE2A>");
tw.WriteLine("<GRPDESCR>twin brothers, and attendants on the two Antipholuses.</GRPDESCR>");
tw.WriteLine("<DOCNAMESPACE>");
tw.WriteLine("<NAMESPACE0 xmlns:bar=\"1\"><bar:check>Namespace=1</bar:check></NAMESPACE0>");
tw.WriteLine("<NAMESPACE1 xmlns:bar=\"1\"><a><b><c><d><bar:check>Namespace=1</bar:check><bar:check2></bar:check2></d></c></b></a></NAMESPACE1>");
tw.WriteLine("<NONAMESPACE>Namespace=\"\"</NONAMESPACE>");
tw.WriteLine("<EMPTY_NAMESPACE bar:Attr0=\"0\" xmlns:bar=\"1\" />");
tw.WriteLine("<EMPTY_NAMESPACE1 Attr0=\"0\" xmlns=\"14\" />");
tw.WriteLine("<EMPTY_NAMESPACE2 Attr0=\"0\" xmlns=\"14\"></EMPTY_NAMESPACE2>");
tw.WriteLine("<NAMESPACE2 xmlns:bar=\"1\"><a><b><c xmlns:bar=\"2\"><d><bar:check>Namespace=2</bar:check></d></c></b></a></NAMESPACE2>");
tw.WriteLine("<NAMESPACE3 xmlns=\"1\"><a xmlns:a=\"2\" xmlns:b=\"3\" xmlns:c=\"4\"><b xmlns:d=\"5\" xmlns:e=\"6\" xmlns:f='7'><c xmlns:d=\"8\" xmlns:e=\"9\" xmlns:f=\"10\">");
tw.WriteLine("<d xmlns:g=\"11\" xmlns:h=\"12\"><check>Namespace=1</check><testns xmlns=\"100\"><empty100 /><check100>Namespace=100</check100></testns><check1>Namespace=1</check1><d:check8>Namespace=8</d:check8></d></c><d:check5>Namespace=5</d:check5></b></a>");
tw.WriteLine("<a13 a:check=\"Namespace=13\" xmlns:a=\"13\" /><check14 xmlns=\"14\">Namespace=14</check14></NAMESPACE3>");
tw.WriteLine("<NONAMESPACE>Namespace=\"\"</NONAMESPACE>");
tw.WriteLine("<NONAMESPACE1 Attr1=\"one\" xmlns=\"1000\">Namespace=\"\"</NONAMESPACE1>");
tw.WriteLine("</DOCNAMESPACE>");
tw.WriteLine("</PGROUP>");
tw.WriteLine("<GOTOCONTENT>some text<![CDATA[cdata info]]></GOTOCONTENT>");
tw.WriteLine("<SKIPCONTENT att1=\"\"> <!-- comment1--> \n <?PI_SkipContent instruction?></SKIPCONTENT>");
tw.WriteLine("<MIXCONTENT> <!-- comment1-->some text<?PI_SkipContent instruction?><![CDATA[cdata info]]></MIXCONTENT>");
tw.WriteLine("<A att=\"123\">1<B>2<C>3<D>4<E>5<F>6<G>7<H>8<I>9<J>10");
tw.WriteLine("<A1 att=\"456\">11<B1>12<C1>13<D1>14<E1>15<F1>16<G1>17<H1>18<I1>19<J1>20");
tw.WriteLine("<A2 att=\"789\">21<B2>22<C2>23<D2>24<E2>25<F2>26<G2>27<H2>28<I2>29<J2>30");
tw.WriteLine("<A3 att=\"123\">31<B3>32<C3>33<D3>34<E3>35<F3>36<G3>37<H3>38<I3>39<J3>40");
tw.WriteLine("<A4 att=\"456\">41<B4>42<C4>43<D4>44<E4>45<F4>46<G4>47<H4>48<I4>49<J4>50");
tw.WriteLine("<A5 att=\"789\">51<B5>52<C5>53<D5>54<E5>55<F5>56<G5>57<H5>58<I5>59<J5>60");
tw.WriteLine("<A6 att=\"123\">61<B6>62<C6>63<D6>64<E6>65<F6>66<G6>67<H6>68<I6>69<J6>70");
tw.WriteLine("<A7 att=\"456\">71<B7>72<C7>73<D7>74<E7>75<F7>76<G7>77<H7>78<I7>79<J7>80");
tw.WriteLine("<A8 att=\"789\">81<B8>82<C8>83<D8>84<E8>85<F8>86<G8>87<H8>88<I8>89<J8>90");
tw.WriteLine("<A9 att=\"123\">91<B9>92<C9>93<D9>94<E9>95<F9>96<G9>97<H9>98<I9>99<J9>100");
tw.WriteLine("<A10 att=\"123\">101<B10>102<C10>103<D10>104<E10>105<F10>106<G10>107<H10>108<I10>109<J10>110");
tw.WriteLine("</J10>109</I10>108</H10>107</G10>106</F10>105</E10>104</D10>103</C10>102</B10>101</A10>");
tw.WriteLine("</J9>99</I9>98</H9>97</G9>96</F9>95</E9>94</D9>93</C9>92</B9>91</A9>");
tw.WriteLine("</J8>89</I8>88</H8>87</G8>86</F8>85</E8>84</D8>83</C8>82</B8>81</A8>");
tw.WriteLine("</J7>79</I7>78</H7>77</G7>76</F7>75</E7>74</D7>73</C7>72</B7>71</A7>");
tw.WriteLine("</J6>69</I6>68</H6>67</G6>66</F6>65</E6>64</D6>63</C6>62</B6>61</A6>");
tw.WriteLine("</J5>59</I5>58</H5>57</G5>56</F5>55</E5>54</D5>53</C5>52</B5>51</A5>");
tw.WriteLine("</J4>49</I4>48</H4>47</G4>46</F4>45</E4>44</D4>43</C4>42</B4>41</A4>");
tw.WriteLine("</J3>39</I3>38</H3>37</G3>36</F3>35</E3>34</D3>33</C3>32</B3>31</A3>");
tw.WriteLine("</J2>29</I2>28</H2>27</G2>26</F2>25</E2>24</D2>23</C2>22</B2>21</A2>");
tw.WriteLine("</J1>19</I1>18</H1>17</G1>16</F1>15</E1>14</D1>13</C1>12</B1>11</A1>");
tw.Write("</J>9</I>8</H>7</G>6</F>5</E>4</D>3</C>2</B>1</A>");
tw.WriteLine("<EMPTY4 val=\"abc\"></EMPTY4>");
tw.WriteLine("<COMPLEX>Text<!-- comment --><![CDATA[cdata]]></COMPLEX>");
tw.WriteLine("<DUMMY />");
tw.WriteLine("<MULTISPACES att=' \r\n \t \r\r\n n1 \r\n \t \r\r\n n2 \r\n \t \r\r\n ' />");
tw.WriteLine("<CAT>AB<![CDATA[CD]]> </CAT>");
tw.WriteLine("<CATMIXED>AB<![CDATA[CD]]> </CATMIXED>");
tw.WriteLine("<VALIDXMLLANG0 xml:lang=\"a\" />");
tw.WriteLine("<VALIDXMLLANG1 xml:lang=\"\" />");
tw.WriteLine("<VALIDXMLLANG2 xml:lang=\"ab-cd-\" />");
tw.WriteLine("<VALIDXMLLANG3 xml:lang=\"a b-cd\" />");
tw.Write("</PLAY>");
tw.Flush();
FilePathUtil.addStream(strFileName, ms);
}
