[mvp-xml-cvs] Common/v2/test/MvpXslTransformTests MvpXslTransformTests.cs,NONE,1.1 out.xml,NONE,1.1 test.xml,NONE,1.1 test1.xslt,NONE,1.1

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/Common/v2/test/MvpXslTransformTests
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv11321/v2/test/MvpXslTransformTests

Added Files:
	MvpXslTransformTests.cs out.xml test.xml test1.xslt 
Log Message:


--- NEW FILE: test1.xslt ---
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:output encoding="utf-8"/>
    <xsl:param name="prm1" select="'default value'"/>
    <xsl:template match="/">
        <out xmlns="foo" bar="" baz="a&amp;b" xmlns:foo="http://schemas.microsoft.com/xsd/catalog">
            <xsl:comment> @#$$ comment</xsl:comment>
            <xsl:processing-instruction name="pi">ghghghgh gh gh"" ''</xsl:processing-instruction>
            <prm1>
              <xsl:value-of select="$prm1" />
            </prm1>
            <xsl:copy-of select="/" />
        </out>
    </xsl:template>
</xsl:stylesheet>
--- NEW FILE: test.xml ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: MvpXslTransformTests.cs ---
using System;
using NUnit.Framework;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;
using System.IO;
using System.Text;
using Mvp.Xml.Common.Xsl;

namespace Mvp.Xml.Tests
{
    [TestFixture]
    public class MvpXslTransformTests 
    {
        byte[] standardResult;
        MvpXslTransform xslt;
        XsltArgumentList args;

        public MvpXslTransformTests()
        {
            XslCompiledTransform xslt = new XslCompiledTransform();
            xslt.Load("../../MvpXslTransformTests/test1.xslt");
            MemoryStream ms = new MemoryStream();
            using (XmlReader r = GetReader(Globals.NorthwindResource))
            {                
                xslt.Transform(r, Arguments, ms);
            }
            standardResult = ms.ToArray();            
        }

        private XsltArgumentList Arguments
        {
            get {
                if (args == null)
                {
                    args = new XsltArgumentList();
                    args.AddParam("prm1", "", "value1");
                }
                return args;
            }
        }

        private MvpXslTransform GetMvpXslTransform()
        {
            if (xslt == null)
            {
                xslt = new MvpXslTransform();
                xslt.Load("../../MvpXslTransformTests/test1.xslt");
            }
            return xslt;
        }

        private static void CompareResults(byte[] standard, byte[] test)
        {
            Assert.AreEqual(standard.Length, test.Length, string.Format("Lengths are different: {0}, {1}", standard.Length, test.Length));
            for (int i = 0; i < standard.Length; i++)
            {
                Assert.IsTrue(standard[i] == test[i], string.Format("Values aren't equal: {0}, {1}, positoin {2}", standard[i], test[i], i));
            }
        }

        private static XmlReader GetReader(string xml)
        {
            XmlReaderSettings s = new XmlReaderSettings();
            s.ProhibitDtd = false;
            return XmlReader.Create(Globals.GetResource(xml), s);
        }

        [Test]
        public void TestStringInput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            MemoryStream ms = new MemoryStream();
            xslt.Transform(input, Arguments, new XmlOutput(ms));
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestStreamInput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            using (FileStream fs = File.OpenRead("../../northwind.xml"))
            {
                XmlInput input = new XmlInput(fs);
                MemoryStream ms = new MemoryStream();
                xslt.Transform(input, Arguments, new XmlOutput(ms));
                CompareResults(standardResult, ms.ToArray());
            }            
        }

        [Test]
        public void TestTextReaderInput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(new StreamReader("../../northwind.xml", Encoding.GetEncoding("windows-1252")));
            MemoryStream ms = new MemoryStream();
            xslt.Transform(input, Arguments, new XmlOutput(ms));
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestXmlReaderInput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(XmlReader.Create("../../northwind.xml"));
            MemoryStream ms = new MemoryStream();
            xslt.Transform(input, Arguments, new XmlOutput(ms));
            CompareResults(standardResult, ms.ToArray());
        }


        [Test]
        public void TestIXPathNavigableInput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(new XPathDocument("../../northwind.xml", XmlSpace.Preserve));
            MemoryStream ms = new MemoryStream();
            xslt.Transform(input, Arguments, new XmlOutput(ms));
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestStringInput2()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            MemoryStream ms = new MemoryStream();
            XmlReader r = xslt.Transform(input, Arguments);
            XmlWriter w = XmlWriter.Create(ms);
            w.WriteNode(r, false);
            w.Close();
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestStreamInput2()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            using (FileStream fs = File.OpenRead("../../northwind.xml"))
            {
                XmlInput input = new XmlInput(fs);
                MemoryStream ms = new MemoryStream();
                XmlReader r = xslt.Transform(input, Arguments);
                XmlWriter w = XmlWriter.Create(ms);
                w.WriteNode(r, false);
                w.Close();
                CompareResults(standardResult, ms.ToArray());
            }
        }

        [Test]
        public void TestTextReaderInput2()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(new StreamReader("../../northwind.xml", Encoding.GetEncoding("windows-1252")));
            MemoryStream ms = new MemoryStream();
            XmlReader r = xslt.Transform(input, Arguments);
            XmlWriter w = XmlWriter.Create(ms);
            w.WriteNode(r, false);
            w.Close();
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestXmlReaderInput2()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(XmlReader.Create("../../northwind.xml"));
            MemoryStream ms = new MemoryStream();
            XmlReader r = xslt.Transform(input, Arguments);
            XmlWriter w = XmlWriter.Create(ms);
            w.WriteNode(r, false);
            w.Close();
            CompareResults(standardResult, ms.ToArray());
        }


        [Test]
        public void TestIXPathNavigableInput2()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput(new XPathDocument("../../northwind.xml", XmlSpace.Preserve));
            MemoryStream ms = new MemoryStream();
            XmlReader r = xslt.Transform(input, Arguments);
            XmlWriter w = XmlWriter.Create(ms);
            w.WriteNode(r, false);
            w.Close();
            CompareResults(standardResult, ms.ToArray());
        }

        [Test]
        public void TestStringOutput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            xslt.Transform(input, Arguments, new XmlOutput("../../MvpXslTransformTests/out.xml"));
            using (FileStream fs = File.OpenRead("../../MvpXslTransformTests/out.xml"))
            {
                byte[] bytes = new byte[fs.Length];
                fs.Read(bytes, 0, bytes.Length);
                CompareResults(standardResult, bytes);
            }            
        }

        [Test]
        public void TestStreamOutput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            using (FileStream outStrm = File.OpenWrite("../../MvpXslTransformTests/out.xml")) {
                xslt.Transform(input, Arguments, new XmlOutput(outStrm));
            }
            using (FileStream fs = File.OpenRead("../../MvpXslTransformTests/out.xml"))
            {
                byte[] bytes = new byte[fs.Length];
                fs.Read(bytes, 0, bytes.Length);
                CompareResults(standardResult, bytes);
            }
        }

        [Test]
        public void TestTextWriterOutput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            TextWriter w = new StreamWriter("../../MvpXslTransformTests/out.xml", false, Encoding.UTF8);
            xslt.Transform(input, Arguments, new XmlOutput(w));
            w.Close();
            using (FileStream fs = File.OpenRead("../../MvpXslTransformTests/out.xml"))
            {
                byte[] bytes = new byte[fs.Length];
                fs.Read(bytes, 0, bytes.Length);
                CompareResults(standardResult, bytes);
            }
        }

        [Test]
        public void TestXmlWriterOutput()
        {
            MvpXslTransform xslt = GetMvpXslTransform();
            XmlInput input = new XmlInput("../../northwind.xml");
            XmlWriter w = XmlWriter.Create("../../MvpXslTransformTests/out.xml");
            xslt.Transform(input, Arguments, new XmlOutput(w));
            w.Close();
            using (FileStream fs = File.OpenRead("../../MvpXslTransformTests/out.xml"))
            {
                byte[] bytes = new byte[fs.Length];
                fs.Read(bytes, 0, bytes.Length);
                CompareResults(standardResult, bytes);
            }
        }        
    }
}

--- NEW FILE: out.xml ---
(This appears to be a binary file; contents omitted.)