/// <summary>
/// Run all methods in each of the listed assemblies
/// </summary>
public void Run(IORMToolServices services, IORMToolTestSuiteReport suiteReport)
{
suiteReport.BeginSuite(myName);
IList <ReportAssembly> allAssemblies = myAssemblies;
if (allAssemblies == null)
{
return;
}
int assemblyCount = allAssemblies.Count;
for (int i = 0; i < assemblyCount; ++i)
{
ReportAssembly testAssembly = allAssemblies[i];
Assembly resolvedAssembly = testAssembly.Assembly;
suiteReport.BeginTestAssembly(testAssembly.Location, resolvedAssembly == null);
if (resolvedAssembly != null)
{
Type[] types = resolvedAssembly.GetTypes();
int typeCount = types.Length;
for (int j = 0; j < typeCount; ++j)
{
Type type = types[j];
if (0 != type.GetCustomAttributes(typeof(ORMTestFixtureAttribute), true).Length)
{
RunTests(type, services, suiteReport);
}
}
}
}
}
//these functions use the current FileInfo object to create
//temporary files. The testInfo object must be set before they are called.
private string GetActualCompare(TestInfo testInfo, ReportAssembly reportAssembly, string missingReport, string extension)
{
Assembly assembly = reportAssembly.Assembly;
foreach (TestClass testclass in reportAssembly.TestClasses)
{
if (testclass.Name == testInfo.TestClassName)
{
foreach (Test test in testclass.Tests)
{
if (test.Name == testInfo.TestName && testclass.TestNamespace == testInfo.TestNamespace)
{
string result = test.Result;
string baseResourceName = testInfo.BaseFileName;
XmlReaderSettings readerSettings = new XmlReaderSettings();
if (result == ReportDiffgram || missingReport != null)
{
using (Stream reportStream = missingReport != null ? null : assembly.GetManifestResourceStream(baseResourceName + ".Report.xml"))
{
if (reportStream != null || missingReport != null)
{
XmlPatch patcher = new XmlPatch();
using (XmlReader reportReader = missingReport != null ?
XmlReader.Create(new StringReader(missingReport)) :
XmlReader.Create(reportStream, readerSettings))
{
StringReader compareStringReader;
if (missingReport != null)
{
compareStringReader = ExtractStringReaderFromCompareByName(reportReader, extension);
}
else
{
using (XmlReader diffReader = XmlReader.Create(new StringReader(test.Content), readerSettings))
{
using (MemoryStream compareStream = new MemoryStream())
{
patcher.Patch(reportReader, new UncloseableStream(compareStream), diffReader);
compareStream.Position = 0;
//the filestream is now the expected test report, containing a compare.
//Now to get that compare...
compareStringReader = ExtractStringReaderFromCompareByName(XmlReader.Create(compareStream), extension);
}
}
}
//and apply the diffgram within in to the original Compare.orm
using (Stream compareStream = assembly.GetManifestResourceStream(string.Format("{0}.{1}", baseResourceName, extension)))
{
if (compareStream != null)
{
using (XmlReader compareReader = XmlReader.Create(compareStream, readerSettings))
{
using (MemoryStream patchedCompareStream = new MemoryStream())
{
using (XmlReader reportCompareReader = XmlReader.Create(compareStringReader, readerSettings))
{
//an exception thrown here is generally caused by the report suite being outdated.
patcher.Patch(compareReader, new UncloseableStream(patchedCompareStream), reportCompareReader);
}
patchedCompareStream.Position = 0;
using (MemoryStream patchedOutputStream = new MemoryStream())
{
using (XmlReader reader = XmlReader.Create(patchedCompareStream))
{
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.Indent = true;
writerSettings.IndentChars = "\t";
writerSettings.CloseOutput = false;
using (XmlWriter writer = XmlWriter.Create(patchedOutputStream, writerSettings))
{
FormatXml(reader, writer);
}
}
patchedOutputStream.Position = 0;
return new StreamReader(patchedOutputStream).ReadToEnd();
}
}
}
}
}
}
}
}
}
return null;
}
}
}
}
Debug.Fail("Internal Error. function: GetActualCompare.");
return null;
}
private ReportAssembly GetReportAssembly(TestInfo testInfo)
{
ReportAssembly reportAssembly = new ReportAssembly();
foreach (ReportSuite reportSuite in myReportSuites)
{
if (reportSuite.Name == testInfo.SuiteName)
{
foreach (ReportAssembly assembly in reportSuite.Assemblies)
{
if (assembly.Location == testInfo.AssemblyLocation)
{
reportAssembly = assembly;
}
}
}
}
Debug.Assert(reportAssembly.Location != null, "Assembly failed to load. ");
return reportAssembly;
}
private string FindMissingReport(TestInfo testInfo, ReportAssembly reportAssembly, bool fakeComparePass)
{
string content = null;
foreach (TestClass testclass in reportAssembly.TestClasses)
{
if (testclass.Name != testInfo.TestClassName || testclass.TestNamespace != testInfo.TestNamespace)
{
continue;
}
foreach (Test test in testclass.Tests)
{
if (test.Name != testInfo.TestName)
{
continue;
}
content = testInfo.Content;
break;
}
break;
}
if (content == null)
{
return "XML failure: Report File Not Found.";
}
if (!fakeComparePass)
{
return content;
}
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.Indent = true;
writerSettings.IndentChars = "\t";
writerSettings.Encoding = Encoding.UTF8;
using (MemoryStream memoryStream = new MemoryStream(content.Length * 2))
{
using (XmlWriter writer = XmlWriter.Create(memoryStream, writerSettings))
{
using (XmlReader reader = XmlReader.Create(new StringReader(content)))
{
// As this is an expected report, it is expected to pass!
// Apply the fake pass template.
XslCompiledTransform transform = FakePassTransform;
transform.Transform(reader, writer);
using (MemoryStream formatStream = new MemoryStream((int)memoryStream.Position))
{
memoryStream.Position = 0;
using (XmlReader formatReader = XmlReader.Create(memoryStream))
{
using (XmlWriter formatWriter = XmlWriter.Create(formatStream, writerSettings))
{
FormatXml(formatReader, formatWriter);
}
}
formatStream.Position = 0;
return new StreamReader(formatStream).ReadToEnd();
}
}
}
}
}
private string GetFakePassReport(TestInfo testInfo, ReportAssembly reportAssembly)
{
Assembly assembly = reportAssembly.Assembly;
XslCompiledTransform transform = FakePassTransform;
XmlReaderSettings readerSettings = new XmlReaderSettings();
string baseResourceName = String.Concat(testInfo.TestNamespace, ".", testInfo.TestClassName, ".", testInfo.TestName);
foreach (TestClass testclass in reportAssembly.TestClasses)
{
if (testclass.Name == testInfo.TestClassName)
{
foreach (Test test in testclass.Tests)
{
if (test.Name == testInfo.TestName && testclass.TestNamespace == testInfo.TestNamespace)
{
MemoryStream patchedStream = null;
try
{
using (Stream stream = assembly.GetManifestResourceStream(baseResourceName + ".Report.xml"))
{
if (stream != null)
{
using (XmlReader reportReader = XmlReader.Create(stream, readerSettings))
{
using (XmlReader diffReader = XmlReader.Create(new StringReader(test.Content), readerSettings))
{
patchedStream = new MemoryStream();
new XmlPatch().Patch(reportReader, new UncloseableStream(patchedStream), diffReader);
}
}
}
else
{
return null;
}
}
patchedStream.Position = 0;
using (XmlReader failReader = XmlReader.Create(patchedStream, readerSettings))
{
using (MemoryStream fakePassStream = new MemoryStream())
{
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.Indent = true;
writerSettings.IndentChars = "\t";
writerSettings.CloseOutput = false;
using (XmlWriter fakePassWriter = XmlWriter.Create(fakePassStream, writerSettings))
{
transform.Transform(failReader, fakePassWriter);
}
fakePassStream.Position = 0;
return new StreamReader(fakePassStream).ReadToEnd();
}
}
}
finally
{
if (patchedStream != null)
{
patchedStream.Dispose();
}
}
}
}
}
}
return null;
}
private string GetExpectedText(TestInfo testInfo, ReportAssembly reportAssembly, string extension)
{
Assembly assembly = reportAssembly.Assembly;
string baseResourceName = String.Concat(testInfo.TestNamespace, ".", testInfo.TestClassName, ".", testInfo.TestName);
string retval = null;
using (Stream stream = assembly.GetManifestResourceStream(string.Format("{0}.{1}", baseResourceName, extension)))
{
if (stream != null)
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
using (XmlReader reader = XmlReader.Create(stream, readerSettings))
{
reader.MoveToContent();
retval = reader.ReadOuterXml();
}
}
else
{
retval = FindMissingCompare(testInfo, assembly, extension);
}
}
return retval;
}
