[mvp-xml-cvs] EXSLT/v2/test/ExsltTest .cvsignore,NONE,1.1 AssemblyInfo.cs,NONE,1.1 AvailabilityTest.cmd,NONE,1.1 ExsltCommonTests.cs,NONE,1.1 ExsltDatesAndTimesTests.cs,NONE,1.1 ExsltMathTests.cs,NONE,1.1 ExsltRandomTests.cs,NONE,1.1 ExsltRegularExpressionsTests.cs,NONE,1.1 ExsltSetsTests.cs,NONE,1.1 ExsltStringsTests.cs,NONE,1.1 ExsltTest.cs,NONE,1.1 ExsltTest.csproj,NONE,1.1 ExsltUnitTests.cs,NONE,1.1 FunctionsAvailability.html,NONE,1.1 GDNDatesAndTimesTests.cs,NONE,1.1 GDNDynamicTests.cs,NONE,1.1 GDNMathTests.cs,NONE,1.1 GDNRegularExpressionsTests.cs,NONE,1.1 GDNSetsTests.cs,NONE,1.1 GDNStringsTests.cs,NONE,1.1

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

Update of /cvsroot/mvp-xml/EXSLT/v2/test/ExsltTest
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv14178/v2/test/ExsltTest

Added Files:
	.cvsignore AssemblyInfo.cs AvailabilityTest.cmd 
	ExsltCommonTests.cs ExsltDatesAndTimesTests.cs 
	ExsltMathTests.cs ExsltRandomTests.cs 
	ExsltRegularExpressionsTests.cs ExsltSetsTests.cs 
	ExsltStringsTests.cs ExsltTest.cs ExsltTest.csproj 
	ExsltUnitTests.cs FunctionsAvailability.html 
	GDNDatesAndTimesTests.cs GDNDynamicTests.cs GDNMathTests.cs 
	GDNRegularExpressionsTests.cs GDNSetsTests.cs 
	GDNStringsTests.cs 
Log Message:


--- NEW FILE: .cvsignore ---
bin
obj
*.user
*.suo
*.exe
*.dll
*.pdb
*.vspscc
--- NEW FILE: FunctionsAvailability.html ---
(This appears to be a binary file; contents omitted.)

--- NEW FILE: ExsltSetsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Sets module functions.
    /// </summary>
    [TestFixture]
    public class ExsltSetsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Sets/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Sets/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     set:difference()
        /// </summary>
        [Test]
        public void DifferenceTest() 
        {
            RunAndCompare("source.xml", "difference.xslt", "difference.xml");
        }
        
        /// <summary>
        /// Tests the following function:
        ///     set:intersection()
        /// </summary>
        [Test]
        public void IntersectionTest() 
        {
            RunAndCompare("source.xml", "intersection.xslt", "intersection.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:distinct()
        /// </summary>
        [Test]
        public void DistinctTest() 
        {
            RunAndCompare("source.xml", "distinct.xslt", "distinct.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:has-same-node()
        /// </summary>
        [Test]
        public void HasSameNodeTest() 
        {
            RunAndCompare("source.xml", "has-same-node.xslt", "has-same-node.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:leading()
        /// </summary>
        [Test]
        public void LeadingTest() 
        {
            RunAndCompare("source.xml", "leading.xslt", "leading.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     set:trailing()
        /// </summary>
        [Test]
        public void TrailingTest() 
        {
            RunAndCompare("source.xml", "trailing.xslt", "trailing.xml");
        }        
    }
}

--- NEW FILE: ExsltRegularExpressionsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT RegularExpressions module functions.
    /// </summary>
    [TestFixture]
    public class ExsltRegularExpressionsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/RegularExpressions/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/RegularExpressions/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     regexp:test()
        /// </summary>
        [Test]
        public void TestTest() 
        {
            RunAndCompare("source.xml", "test.xslt", "test.xml");
        }   
         
        /// <summary>
        /// Tests the following function:
        ///     regexp:match()
        /// </summary>
        [Test]
        public void MatchTest() 
        {
            RunAndCompare("source.xml", "match.xslt", "match.xml");
        }   

        /// <summary>
        /// Tests the following function:
        ///     regexp:replace()
        /// </summary>
        [Test]
        public void ReplaceTest() 
        {
            RunAndCompare("source.xml", "replace.xslt", "replace.xml");
        }   
    }
}

--- NEW FILE: ExsltStringsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
	/// <summary>
	/// Collection of unit tests for EXSLT Strings module functions.
	/// </summary>
	[TestFixture]
	public class ExsltStringsTests : ExsltUnitTests
	{        
        protected override string TestDir 
        {
            get { return "tests/EXSLT/Strings/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Strings/"; }
        }                

        /// <summary>
        /// Tests the following function:
        ///     str:tokenize()
        /// </summary>
        [Test]
        public void TokenizeTest() 
        {
            RunAndCompare("source.xml", "tokenize.xslt", "tokenize.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:replace()
        /// </summary>
        [Test]
        public void ReplaceTest() 
        {
            RunAndCompare("source.xml", "replace.xslt", "replace.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:padding()
        /// </summary>
        [Test]
        public void PaddingTest() 
        {
            RunAndCompare("source.xml", "padding.xslt", "padding.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:align()
        /// </summary>
        [Test]
        public void AlignTest() 
        {
            RunAndCompare("source.xml", "align.xslt", "align.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:encode-uri()
        /// </summary>
        [Test]
        public void EncodeUriTest() 
        {
            RunAndCompare("source.xml", "encode-uri.xslt", "encode-uri.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:decode-uri()
        /// </summary>
        [Test]
        public void DecodeUriTest() 
        {
            RunAndCompare("source.xml", "decode-uri.xslt", "decode-uri.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:concat()
        /// </summary>
        [Test]
        public void ConcatTest() 
        {
            RunAndCompare("source.xml", "concat.xslt", "concat.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str:split()
        /// </summary>
        [Test]
        public void SplitTest() 
        {
            RunAndCompare("source.xml", "split.xslt", "split.xml");
        }
	}
}

--- NEW FILE: GDNDatesAndTimesTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Dates and Times module functions.
    /// </summary>
    [TestFixture]
    public class GDNDatesAndTimesTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/DatesAndTimes/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/DatesAndTimes/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     date2:avg()
        /// </summary>
        [Test]
        public void AvgTest() 
        {
            RunAndCompare("source.xml", "avg.xslt", "avg.xml");
        } 
        
        /// <summary>
        /// Tests the following function:
        ///     date2:min()
        /// </summary>
        [Test]
        public void MinTest() 
        {
            RunAndCompare("source.xml", "min.xslt", "min.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:max()
        /// </summary>
        [Test]
        public void MaxTest() 
        {
            RunAndCompare("source.xml", "max.xslt", "max.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:day-name()
        /// </summary>
        [Test]
        public void DayNameTest() 
        {
            RunAndCompare("source.xml", "day-name.xslt", "day-name.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:day-abbreviation()
        /// </summary>
        [Test]
        public void DayAbbreviationTest() 
        {
            RunAndCompare("source.xml", "day-abbreviation.xslt", "day-abbreviation.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:month-name()
        /// </summary>
        [Test]
        public void MonthNameTest() 
        {
            RunAndCompare("source.xml", "month-name.xslt", "month-name.xml");
        } 

        /// <summary>
        /// Tests the following function:
        ///     date2:month-abbreviation()
        /// </summary>
        [Test]
        public void MonthAbbreviationTest() 
        {
            RunAndCompare("source.xml", "month-abbreviation.xslt", "month-abbreviation.xml");
        } 
    }
}

--- NEW FILE: GDNDynamicTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Dynamic module functions.
    /// </summary>
    [TestFixture]
    public class GDNDynamicTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Dynamic/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Dynamic/"; }
        } 
        
        /// <summary>
        /// Tests the following function:
        ///     dyn2:evaluate()
        /// </summary>
        [Test]
        public void EvaluateTest() 
        {
            RunAndCompare("source.xml", "evaluate.xslt", "evaluate.xml");
        }        
    }
}

--- NEW FILE: GDNMathTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Math module functions.
    /// </summary>
    [TestFixture]
    public class GDNMathTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Math/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Math/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     math2:avg()
        /// </summary>
        [Test]
        public void AvgTest() 
        {
            RunAndCompare("source.xml", "avg.xslt", "avg.xml");
        }                 
    }
}

--- NEW FILE: GDNStringsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Strings module functions.
    /// </summary>
    [TestFixture]
    public class GDNStringsTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Strings/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Strings/"; }
        }                

        /// <summary>
        /// Tests the following function:
        ///     str2:lowercase()
        /// </summary>
        [Test]
        public void LowercaseTest() 
        {
            RunAndCompare("source.xml", "lowercase.xslt", "lowercase.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     str2:uppercase()
        /// </summary>
        [Test]
        public void UppercaseTest() 
        {
            RunAndCompare("source.xml", "uppercase.xslt", "uppercase.xml");
        }
    }
}

--- NEW FILE: AvailabilityTest.cmd ---
ExsltTest tests\test.xml tests\availability.xslt FunctionsAvailability.html
--- NEW FILE: ExsltUnitTests.cs ---
using System;
using Mvp.Xml.Exslt;
using System.Xml;
using System.Xml.XPath;
using System.IO;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Superclass for unit tests.
    /// </summary>
    public class ExsltUnitTests
    {
        protected virtual string TestDir 
        {
            get { return "tests/EXSLT/Common/"; }
        }
        protected virtual string ResultsDir 
        {
            get { return "results/EXSLT/Common/"; }
        }

        protected void RunAndCompare(string source, string stylesheet, 
            string result) 
        {
            XPathDocument doc = new XPathDocument(TestDir + source);            
            ExsltTransform exslt = new ExsltTransform();
            exslt.Load(TestDir + stylesheet);
            StringWriter res = new StringWriter();
            exslt.Transform(doc, null, res);
            StreamReader sr = new StreamReader(ResultsDir + result);
            string expectedResult = sr.ReadToEnd();
            sr.Close();
			if (res.ToString() != expectedResult)
			{
				Console.WriteLine("Actual Result was {0}", res.ToString());
				Console.WriteLine("Expected Result was {0}", expectedResult);
			}
            Assert.IsTrue(res.ToString() == expectedResult);
        }        
    }
}

--- NEW FILE: ExsltTest.cs ---
using System;
using Mvp.Xml.Exslt;
using System.Xml;
using System.Xml.XPath;
using System.IO;

namespace ExsltTest
{
	/// <summary>
	/// Primitive command-line EXSLT-aware utility.
	/// </summary>
    public class ExsltTest
    {
		public static void Main(string[] args) {
		    if (args.Length != 3) {		    
		        PrintUsage();
		        return;
		    }
		    try {    
		        XPathDocument doc = new XPathDocument(args[0]);
		        ExsltTransform xslt = new ExsltTransform();		        
		        xslt.Load(args[1]);
		        xslt.MultiOutput = false;
		        using (FileStream fs = File.Create(args[2])) {
		            xslt.Transform(doc, null, fs);
		        }
		    } catch (Exception e) {
		        Console.Error.WriteLine("An exception occured: ");
		        Console.Error.WriteLine(e);
		    }
		}		
		
		private static void PrintUsage() {
		    Console.WriteLine("ExsltTest usage:");
		    Console.WriteLine("ExsltTest.exe source stylesheet result");
		}
	}
}

--- NEW FILE: GDNRegularExpressionsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet RegularExpressions module functions.
    /// </summary>
    [TestFixture]
    public class GDNRegularExpressionsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/GotDotNet/RegularExpressions/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/RegularExpressions/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     regexp2:tokenize()
        /// </summary>
        [Test]
        public void TokenizeTest() 
        {
            RunAndCompare("source.xml", "tokenize.xslt", "tokenize.xml");
        }                    
    }
}

--- NEW FILE: ExsltRandomTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Random module functions.
    /// </summary>
    [TestFixture]
    public class ExsltRandomTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Random/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Random/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     random:random-sequence()
        /// </summary>
        [Test]
        public void RandomSequenceTest() 
        {
            RunAndCompare("source.xml", "random-sequence.xslt", "random-sequence.xml");
        }          
    }
}

--- NEW FILE: ExsltDatesAndTimesTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Dates and Times module functions.
    /// </summary>
    [TestFixture]
    public class ExsltDatesAndTimesTests : ExsltUnitTests
    {        
        protected override string TestDir 
        {
            get { return "tests/EXSLT/DatesAndTimes/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/DatesAndTimes/"; }
        }   
        
        /// <summary>
        /// Tests the following function:
        ///     date:format-date()
        /// </summary>
        [Test]
        public void FormatDateTest() 
        {
            RunAndCompare("source.xml", "format-date.xslt", "format-date.xml");
        }                

        /// <summary>
        /// Tests the following function:
        ///     date:parse-date()
        /// </summary>
        [Test]
        public void ParseDateTest() 
        {
            RunAndCompare("source.xml", "parse-date.xslt", "parse-date.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:date-time()
        /// </summary>
        [Test]
        public void DateTimeTest() 
        {
            RunAndCompare("source.xml", "date-time.xslt", "date-time.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:date()
        /// </summary>
        [Test]
        public void DateTest() 
        {
            RunAndCompare("source.xml", "date.xslt", "date.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:time()
        /// </summary>
        [Test]
        public void TimeTest() 
        {
            RunAndCompare("source.xml", "time.xslt", "time.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:year()
        /// </summary>
        [Test]
        public void YearTest() 
        {
            RunAndCompare("source.xml", "year.xslt", "year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:leap-year()
        /// </summary>
        [Test]
        public void LeapYearTest() 
        {
            RunAndCompare("source.xml", "leap-year.xslt", "leap-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-in-year()
        /// </summary>
        [Test]
        public void MonthInYearTest() 
        {
            RunAndCompare("source.xml", "month-in-year.xslt", "month-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-name()
        /// </summary>
        [Test]
        public void MonthNameTest() 
        {
            RunAndCompare("source.xml", "month-name.xslt", "month-name.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:month-abbreviation()
        /// </summary>
        [Test]
        public void MonthAbbreviationTest() 
        {
            RunAndCompare("source.xml", "month-abbreviation.xslt", "month-abbreviation.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-in-year()
        /// </summary>
        [Test]
        public void WeekInYearTest() 
        {
            RunAndCompare("source.xml", "week-in-year.xslt", "week-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-in-month()
        /// </summary>
        [Test]
        public void WeekInMonthTest() 
        {
            RunAndCompare("source.xml", "week-in-month.xslt", "week-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-year()
        /// </summary>
        [Test]
        public void DayInYearTest() 
        {
            RunAndCompare("source.xml", "day-in-year.xslt", "day-in-year.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-month()
        /// </summary>
        [Test]
        public void DayInMonthTest() 
        {
            RunAndCompare("source.xml", "day-in-month.xslt", "day-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:week-of-week-in-month()
        /// </summary>
        [Test]
        public void DayOfWeekInMonthTest() 
        {
            RunAndCompare("source.xml", "day-of-week-in-month.xslt", "day-of-week-in-month.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-in-week()
        /// </summary>
        [Test]
        public void DayInWeekTest() 
        {
            RunAndCompare("source.xml", "day-in-week.xslt", "day-in-week.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-name()
        /// </summary>
        [Test]
        public void DayNameTest() 
        {
            RunAndCompare("source.xml", "day-name.xslt", "day-name.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:day-abbreviation()
        /// </summary>
        [Test]
        public void DayAbbreviationTest() 
        {
            RunAndCompare("source.xml", "day-abbreviation.xslt", "day-abbreviation.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:hour-in-day()
        /// </summary>
        [Test]
        public void HourInDayTest() 
        {
            RunAndCompare("source.xml", "hour-in-day.xslt", "hour-in-day.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:minute-in-hour()
        /// </summary>
        [Test]
        public void MinuteInHourTest() 
        {
            RunAndCompare("source.xml", "minute-in-hour.xslt", "minute-in-hour.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:second-in-minute()
        /// </summary>
        [Test]
        public void SecondInMinuteTest() 
        {
            RunAndCompare("source.xml", "second-in-minute.xslt", "second-in-minute.xml");
        }
        
        /// <summary>
        /// Tests the following function:
        ///     date:difference()
        /// </summary>
        [Test]
        public void DifferenceTest() 
        {
            RunAndCompare("source.xml", "difference.xslt", "difference.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:add()
        /// </summary>
        [Test]
        public void AddTest() 
        {
            RunAndCompare("source.xml", "add.xslt", "add.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:add-duration()
        /// </summary>
        [Test]
        public void AddDurationTest() 
        {
            RunAndCompare("source.xml", "add-duration.xslt", "add-duration.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:sum()
        /// </summary>
        [Test]
        public void SumTest() 
        {
            RunAndCompare("source.xml", "sum.xslt", "sum.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:seconds()
        /// </summary>
        [Test]
        public void SecondsTest() 
        {
            RunAndCompare("source.xml", "seconds.xslt", "seconds.xml");
        }

        /// <summary>
        /// Tests the following function:
        ///     date:duration()
        /// </summary>
        [Test]
        public void DurationTest() 
        {
            RunAndCompare("source.xml", "duration.xslt", "duration.xml");
        }
    }
}

--- NEW FILE: GDNSetsTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for GotDotNet Sets module functions.
    /// </summary>
    [TestFixture]
    public class GDNSetsTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/GotDotNet/Sets/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/GotDotNet/Sets/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     set2:subset()
        /// </summary>
        [Test]
        public void SubsetTest() 
        {
            RunAndCompare("source.xml", "subset.xslt", "subset.xml");
        }                
    }
}

--- NEW FILE: ExsltMathTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Math module functions.
    /// </summary>
    [TestFixture]
    public class ExsltMathTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Math/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Math/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     math:min()
        /// </summary>
        [Test]
        public void MinTest() 
        {
            RunAndCompare("source.xml", "min.xslt", "min.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:max()
        /// </summary>
        [Test]
        public void MaxTest() 
        {
            RunAndCompare("source.xml", "max.xslt", "max.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:highest()
        /// </summary>
        [Test]
        public void HighestTest() 
        {
            RunAndCompare("source.xml", "highest.xslt", "highest.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:lowest()
        /// </summary>
        [Test]
        public void LowestTest() 
        {
            RunAndCompare("source.xml", "lowest.xslt", "lowest.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:abs()
        /// </summary>
        [Test]
        public void AbsTest() 
        {
            RunAndCompare("source.xml", "abs.xslt", "abs.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:sqrt()
        /// </summary>
        [Test]
        public void SqrtTest() 
        {
            RunAndCompare("source.xml", "sqrt.xslt", "sqrt.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:power()
        /// </summary>
        [Test]
        public void PowerTest() 
        {
            RunAndCompare("source.xml", "power.xslt", "power.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:constant()
        /// </summary>
        [Test]
        public void ConstantTest() 
        {
            RunAndCompare("source.xml", "constant.xslt", "constant.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:log()
        /// </summary>
        [Test]
        public void LogTest() 
        {
            RunAndCompare("source.xml", "log.xslt", "log.xml");
        }            
    
        /// <summary>
        /// Tests the following function:
        ///     math:random()
        /// </summary>
        [Test]
        public void RandomTest() 
        {
            RunAndCompare("source.xml", "random.xslt", "random.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:sin()
        /// </summary>
        [Test]
        public void SinTest() 
        {
            RunAndCompare("source.xml", "sin.xslt", "sin.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:cos()
        /// </summary>
        [Test]
        public void CosTest() 
        {
            RunAndCompare("source.xml", "cos.xslt", "cos.xml");
        }            
        
        /// <summary>
        /// Tests the following function:
        ///     math:tan()
        /// </summary>
        [Test]
        public void TanTest() 
        {
            RunAndCompare("source.xml", "tan.xslt", "tan.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:asin()
        /// </summary>
        [Test]
        public void AsinTest() 
        {
            RunAndCompare("source.xml", "asin.xslt", "asin.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:acos()
        /// </summary>
        [Test]
        public void AcosTest() 
        {
            RunAndCompare("source.xml", "acos.xslt", "acos.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:atan()
        /// </summary>
        [Test]
        public void AtanTest() 
        {
            RunAndCompare("source.xml", "atan.xslt", "atan.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:atan2()
        /// </summary>
        [Test]
        public void Atan2Test() 
        {
            RunAndCompare("source.xml", "atan2.xslt", "atan2.xml");
        }            

        /// <summary>
        /// Tests the following function:
        ///     math:exp()
        /// </summary>
        [Test]
        public void ExpTest() 
        {
            RunAndCompare("source.xml", "exp.xslt", "exp.xml");
        }            
    }
}

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

--- NEW FILE: AssemblyInfo.cs ---
using System.Reflection;
using System.Runtime.CompilerServices;

//
// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly: AssemblyTitle("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("")]
[assembly: AssemblyCopyright("")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]		

//
// Version information for an assembly consists of the following four values:
//
//      Major Version
//      Minor Version 
//      Build Number
//      Revision
//
// You can specify all the values or you can default the Revision and Build Numbers 
// by using the '*' as shown below:

[assembly: AssemblyVersion("1.0.*")]

//
// In order to sign your assembly you must specify a key to use. Refer to the 
// Microsoft .NET Framework documentation for more information on assembly signing.
//
// Use the attributes below to control which key is used for signing. 
//
// Notes: 
//   (*) If no key is specified, the assembly is not signed.
//   (*) KeyName refers to a key that has been installed in the Crypto Service
//       Provider (CSP) on your machine. KeyFile refers to a file which contains
//       a key.
//   (*) If the KeyFile and the KeyName values are both specified, the 
//       following processing occurs:
//       (1) If the KeyName can be found in the CSP, that key is used.
//       (2) If the KeyName does not exist and the KeyFile does exist, the key 
//           in the KeyFile is installed into the CSP and used.
//   (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
//       When specifying the KeyFile, the location of the KeyFile should be
//       relative to the project output directory which is
//       %Project Directory%\obj\<configuration>. For example, if your KeyFile is
//       located in the project directory, you would specify the AssemblyKeyFile 
//       attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
//   (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
//       documentation for more information on this.
//
[assembly: AssemblyDelaySign(false)]
[assembly: AssemblyKeyFile("")]
[assembly: AssemblyKeyName("")]

--- NEW FILE: ExsltCommonTests.cs ---
using System;
using NUnit.Framework;

namespace ExsltTest
{
    /// <summary>
    /// Collection of unit tests for EXSLT Common module functions.
    /// </summary>
    [TestFixture]
    public class ExsltCommonTests : ExsltUnitTests
    {        

        protected override string TestDir 
        {
            get { return "tests/EXSLT/Common/"; }
        }
        protected override string ResultsDir 
        {
            get { return "results/EXSLT/Common/"; }
        }   
                       
        /// <summary>
        /// Tests the following function:
        ///     exsl:node-set()
        /// </summary>
        [Test]
        public void NodeSetTest() 
        {
            RunAndCompare("source.xml", "node-set.xslt", "node-set.xml");
        }        

        /// <summary>
        /// Tests the following function:
        ///     exsl:object-type()
        /// </summary>
        [Test]
        public void ObjectTypeTest() 
        {
            RunAndCompare("source.xml", "object-type.xslt", "object-type.xml");
        }        
    }
}