GithubStar/32feet
1
0
Fork 0
mirror of https://github.com/inthehand/32feet.git synced 2026-10-20 15:42:43 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
development
32feet/Legacy/Testing/UnitTesting/NETCF/NetcfTestRunner/NetcfTestRunner.cs
T
Peter Freeman Foot b7eee1481f Moved legacy code and added new .NET Standard projects
2020-01-13 12:56:21 +00:00

673 lines
26 KiB
C#
Raw Permalink Blame History

#region Copyright (c) 2007, Andy Hume <andyhume32@yahoo.co.uk>
/************************************************************************************
'
' Copyright © 2007, Andy Hume
'
' This software is provided 'as-is', without any express or implied warranty. In no
' event will the authors be held liable for any damages arising from the use of this
' software.
'
' Permission is granted to anyone to use this software for any purpose, including
' commercial applications, and to alter it and redistribute it freely, subject to the
' following restrictions:
'
' 1. The origin of this software must not be misrepresented; you must not claim that
' you wrote the original software. If you use this software in a product, an
' acknowledgment (see the following) in the product documentation is required.
'
' Copyright © 2007, Andy Hume
'
' 2. Altered source versions must be plainly marked as such, and must not be
' misrepresented as being the original software.
'
' 3. This notice may not be removed or altered from any source distribution.
'
'***********************************************************************************/
#endregion
using System;
#if ! FX1_1
using System.Collections.Generic;
#endif
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Reflection;
namespace NetcfTestRunner
{
public class NetcfTestRunnerWorkings
{
private Form1 m_form1;
private Assembly m_testeeAssembly;
//
System.Windows.Forms.OpenFileDialog openFileDialogTesteeAssembly;
System.Windows.Forms.SaveFileDialog saveFileDialog1;
//----------------------------------------------------------------------
internal NetcfTestRunnerWorkings(Form1 form1)
{
m_form1 = form1;
SetTesteeAssembly(typeof(InTheHand.Net.Tests.Sdp2.SdpHelperTests).Assembly);
SetUiStateIdle();
CreateFileDialogs();
}
//----------------------------------------------------------------------
void SetUiStateIdle()
{
m_form1.menuItemRunAll.Enabled = true;
m_form1.menuItemRunAll2.Enabled = true;
m_form1.menuItemRunSelected.Enabled = true;
m_form1.menuItemStop.Enabled = false;
}
void SetUiStateRunning()
{
m_form1.label1.Text = "Started...";
m_form1.menuItemRunAll.Enabled = false;
m_form1.menuItemRunAll2.Enabled = false;
m_form1.menuItemRunSelected.Enabled = false;
m_form1.menuItemStop.Enabled = true;
m_userStopRequested = false;
}
//----------------------------------------------------------------------
internal void menuQuit_Click(object sender, EventArgs e)
{
m_form1.Close();
}
internal void Form1_Load(object sender, EventArgs e)
{
Version clrVersion = Environment.Version;
String clr = "CLR: " + clrVersion.ToString();
OperatingSystem osVersion = Environment.OSVersion;
String os = "OS: " + osVersion.ToString();
m_form1.listView1.Items.Add(new ListViewItem(clr));
m_form1.listView1.Items.Add(new ListViewItem(os));
}
private void SetTesteeAssembly(Assembly assm)
{
Type ttu = assm.GetType("InTheHand.Net.Tests.TestsUtils");
System.Diagnostics.Debug.Assert(ttu != null, "NO TestUtils?!!");
if (ttu != null) {
MethodInfo mi = ttu.GetMethod("SetIsInNetcfTestRunner",
BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
System.Diagnostics.Debug.Assert(mi != null, "NO SetIsInNetcfTestRunner?!!");
if (mi != null) {
mi.Invoke(null, null);
}
}
//----
m_form1.comboBox1.DataSource = null;
m_testeeAssembly = assm;
}
Assembly GetTesteeAssembly()
{
return m_testeeAssembly;
}
internal void buttonStop_Click(object sender, EventArgs e)
{
m_userStopRequested = true;
}
internal void comboBox1_GotFocus(object sender, EventArgs e)
{
if (m_form1.comboBox1.DataSource == null) {
try {
Cursor.Current = Cursors.WaitCursor;
Type[] allTestTypes = GetAllTestClasses(GetTesteeAssembly());
m_form1.comboBox1.DisplayMember = "Name";
m_form1.comboBox1.DataSource = allTestTypes;
} finally {
Cursor.Current = Cursors.Default;
}
}
}//fn
internal void buttonAllClasses_Click(object sender, EventArgs e)
{
DoTestsOnAllClasses(GetTesteeAssembly());
}
internal void buttonSelectedClass_Click(object sender, EventArgs e)
{
// Check the value we get out of the ComboBox...
Object selectedValue = m_form1.comboBox1.SelectedValue;
Type selectedType = selectedValue as Type;
// Go.
if (selectedType == null) {
MessageBox.Show("No class selected.");
} else {
DoTestsOnClass(selectedType);
}
}
internal void buttonShowSelectedMessage_Click(object sender, EventArgs e)
{
String message;
if (m_form1.listView1.SelectedIndices.Count > 0) {
message = ((ListViewItem)m_form1.listView1.Items[m_form1.listView1.SelectedIndices[0]]).Text;
} else {
message = ((ListViewItem)m_form1.listView1.Items[0]).Text;
}
if (message == null) {
} else {
MessageBox.Show(message);
}
}
internal void buttonSave_Click(object sender, EventArgs e)
{
string fileName;
if (!GetLogFileName(out fileName)) {
return;
}
//
using (System.IO.TextWriter wtr
= new System.IO.StreamWriter(fileName, false, System.Text.Encoding.UTF8)) {
Version clrVersion = Environment.Version;
OperatingSystem osVersion = Environment.OSVersion;
wtr.WriteLine("OS Version: " + osVersion.ToString()
+ " .NET Version: " + clrVersion.ToString());
wtr.WriteLine();
foreach (ListViewItem row in m_form1.listView1.Items) {
String text = row.Text;
wtr.WriteLine(text);
}//for
}//using
}
internal void menuItemLoadAssembly_Click(object sender, EventArgs e)
{
string fileName;
if (!GetAssemblyFilename(out fileName)) {
return;
}
Assembly assm = Assembly.LoadFrom(fileName);
SetTesteeAssembly(assm);
}
//----------------------------------------------------------------------
void CreateFileDialogs()
{
try {
saveFileDialog1 = new System.Windows.Forms.SaveFileDialog();
saveFileDialog1.FileName = m_form1.saveFileDialog1_FileName;
} catch (NotSupportedException) {
// SmartPhone?!
}
try{
openFileDialogTesteeAssembly = new System.Windows.Forms.OpenFileDialog();
openFileDialogTesteeAssembly.Filter = "DLLs (*.dll)|*.dll|Apps (*.exe)|*.exe|All files (*.*)|*.*";
} catch (NotSupportedException) {
// SmartPhone?!
}
}
internal bool GetLogFileName(out string fileName)
{
if (saveFileDialog1 == null) {
fileName = m_form1.saveFileDialog1_FileName;
#if !FX1_1
string mydocs = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
#else
string mydocs = @"\My Documents";
#endif
fileName = System.IO.Path.Combine(mydocs, fileName);
return true;
}
DialogResult rslt = saveFileDialog1.ShowDialog();
if (rslt == DialogResult.OK) {
fileName = saveFileDialog1.FileName;
return true;
} else {
fileName = null;
return false;
}
}
internal bool GetAssemblyFilename(out string fileName)
{
if (openFileDialogTesteeAssembly == null) {
fileName = null;
return false;
}
DialogResult rslt = openFileDialogTesteeAssembly.ShowDialog();
if (rslt == DialogResult.OK) {
fileName = openFileDialogTesteeAssembly.FileName;
return true;
} else {
fileName = null;
return false;
}
}
//----------------------------------------------------------------------
bool m_userStopRequested;
long m_progressCount;
long m_progressCountOfTestClasses;
long m_countOfRunningTestClasses;
String m_progressText;
long m_countPassed;
long m_countNotRun;
long m_countFailedByAssert;
long m_countFailedByException;
private void PrepareForTests()
{
if (m_form1.InvokeRequired) {
m_form1.Invoke(new EventHandler(PrepareForTests__));
} else {
PrepareForTests__(null, null);
}
}
private void PrepareForTests__(object sender, EventArgs e)
{
SetUiStateRunning();
//
m_countOfRunningTestClasses = m_progressCountOfTestClasses = 0;
m_progressCount = 0;
m_countPassed = m_countNotRun = m_countFailedByAssert = m_countFailedByException = 0;
m_progressText = String.Empty;
//
m_form1.listView1.Items.Clear();
// For dots.
m_form1.listView1.Items.Add(new ListViewItem(""));
// For counts
m_form1.listView1.Items.Add(new ListViewItem(""));
#if ! FX1_1
m_FailedByException = new List<string>();
#else
m_FailedByException = new System.Collections.ArrayList();
#endif
}
private void TestsFinished()
{
if (m_form1.InvokeRequired) {
m_form1.Invoke(new EventHandler(TestsFinished__));
} else {
TestsFinished__(null, null);
}
}
private void TestsFinished__(object sender, EventArgs e)
{
UpdateProgress();
const String LogHeaderLine = "------------------------------------------------------------";
WriteToLog(LogHeaderLine);
//
((ListViewItem)m_form1.listView1.Items[0]).Text += "]]]";
((ListViewItem)m_form1.listView1.Items[1]).Text
+= "Pass " + m_countPassed
+ ", NtRn " + m_countNotRun
+ ", Ex " + m_countFailedByException
+ ", Asrt " + m_countFailedByAssert
+ ".";
WriteToLog(((ListViewItem)m_form1.listView1.Items[0]).Text);
WriteToLog(((ListViewItem)m_form1.listView1.Items[1]).Text);
//
int i = 1;
foreach (String failedMessage in m_FailedByException) {
m_form1.listView1.Items.Add(new ListViewItem(failedMessage));
WriteToLog((String)failedMessage);
++i;
}
//
WriteToLog(LogHeaderLine);
SetUiStateIdle();
}
private void WriteToLog(String line)
{
System.Diagnostics.Debug.WriteLine(line);
Console.WriteLine(line);
}
private void TheTestPassed(MethodInfo curMethod)
{
m_countPassed++;
AddProgressDot(".");
}
private void AddProgressDot(String dotOrFOrEtc)
{
m_progressText += dotOrFOrEtc;
//----
if (m_form1.InvokeRequired) {
m_form1.Invoke(new EventHandler(AddProgressDot__));
return;
} else {
AddProgressDot__(null, null);
}
}
void AddProgressDot__(object sender, EventArgs e)
{
m_progressCount++;
UpdateProgress();
((ListViewItem)m_form1.listView1.Items[0]).Text = m_progressText;
}
private void UpdateProgress()
{
m_form1.label1.Text = m_progressCount.ToString()
+ " (" + m_progressCountOfTestClasses.ToString() + "/" + m_countOfRunningTestClasses.ToString() + ")";
}
#if ! FX1_1
List<String> m_FailedByException;
#else
System.Collections.ArrayList m_FailedByException;
#endif
Type m_testFailedByExceptionLastType;
private void TheTestFailedByException(MethodInfo testMethod, Exception failureException)
{
m_countFailedByException++;
// Now the message
String message = String.Empty;
NUnit.Framework.AssertionException exceptionAsAssertionEx
= failureException as NUnit.Framework.AssertionException;
if (exceptionAsAssertionEx != null) {
message += exceptionAsAssertionEx.Message;
AddProgressDot("F");
} else {
// Not 'FullName' as it's too long.
message += failureException.GetType().Name + ": " + failureException.Message;
AddProgressDot("E");
}
TheTestFailed__(testMethod, message);
}
private void TheTestNotRun(MethodInfo testMethod, string ignoreMessage)
{
m_countNotRun++;
AddProgressDot("N");
TheTestFailed__(testMethod, ignoreMessage, true);
}
private void TheTestFailedByNotExpectedException(MethodInfo testMethod, NUnit.Framework.ExpectedExceptionAttribute[] expExAttrs)
{
m_countFailedByAssert++;
//
String message = String.Empty;
//message += "{" + expExAttrs.Length.ToString() + "} ";
NUnit.Framework.ExpectedExceptionAttribute attribute = expExAttrs[0];
if (attribute.ExceptionName != null) {
message += attribute.ExceptionName;
} else {
message += attribute.ExceptionType.Name;
}
message += " was expected.";
//
AddProgressDot("F");
TheTestFailed__(testMethod, message);
}
private void TheTestFailed__(MethodInfo testMethod, String message)
{
TheTestFailed__(testMethod, message, string.Empty);
}
private void TheTestFailed__(MethodInfo testMethod, String message, bool ignored)
{
TheTestFailed__(testMethod, message, ignored ? "ignored" : string.Empty);
}
private void TheTestFailed__(MethodInfo testMethod, String message, string classification)
{
// Log the failing test's containing class, but only the first time for each class.
Type testType = testMethod.ReflectedType; // .DeclaringType is wrong.
if (!testType.Equals(m_testFailedByExceptionLastType)) {
m_testFailedByExceptionLastType = testType;
String noteNewClass = "* " + testType.Name;
m_FailedByException.Add(noteNewClass);
}
m_FailedByException.Add("**" + classification + " " + testMethod.Name + ": " + message);
}
//----------------------------------------------------------------------
bool DoTestsOnBackgroundThread = true;
delegate void DoTestWithTypeDelegate(Type type);
void DoTestsOnClass(Type testFixture)
{
if (DoTestsOnBackgroundThread) {
System.Threading.ThreadPool.QueueUserWorkItem(
new System.Threading.WaitCallback(DoTestsOnClass__), testFixture);
} else {
DoTestsOnClass__(testFixture);
}
}
void DoTestsOnClass__(Object testFixture)
{
PrepareForTests();
//
m_countOfRunningTestClasses = 1;
StringBuilder timings = new StringBuilder();
InternalDoTestsOnClass((Type)testFixture, timings);
//
SaveTimings(timings);
TestsFinished();
}
void DoTestsOnAllClasses(Assembly assemblyToBeTested)
{
if (DoTestsOnBackgroundThread) {
System.Threading.ThreadPool.QueueUserWorkItem(
new System.Threading.WaitCallback(DoTestsOnAllClasses__), assemblyToBeTested);
} else {
DoTestsOnAllClasses__(assemblyToBeTested);
}
}
void DoTestsOnAllClasses__(Object assemblyToBeTestedAsObject)
{
try {
PrepareForTests();
StringBuilder timings = new StringBuilder();
//
Type[] allTypes = GetAllTestClasses(assemblyToBeTestedAsObject);
m_countOfRunningTestClasses = allTypes.Length;
foreach (Type type in allTypes) {
if (m_userStopRequested) {
break;
}
//Object instance = Activator.CreateInstance(type);
InternalDoTestsOnClass(type, timings);
}
//
SaveTimings(timings);
TestsFinished();
} catch (Exception ex) {
WriteToLog(ex.ToString());
m_FailedByException.Add("Runner failed with: " + ex);
TestsFinished();
throw;
}
}
private static void SaveTimings(StringBuilder timings)
{
using (System.IO.StreamWriter dst = System.IO.File.CreateText("timings.csv")) {
dst.Write(timings.ToString());
}
}
private static Type[] GetAllTestClasses(Object assemblyToBeTestedAsObject)
{
Assembly assemblyToBeTested = (Assembly)assemblyToBeTestedAsObject;
Type[] allTypes = assemblyToBeTested.GetTypes();
#if ! FX1_1
List<Type> testTypes = new List<Type>();
#else
System.Collections.ArrayList testTypes = new System.Collections.ArrayList();
#endif
foreach (Type type in allTypes) {
bool defined = type.IsDefined(typeof(NUnit.Framework.TestFixtureAttribute), false);
Object[] attributes = type.GetCustomAttributes(
typeof(NUnit.Framework.TestFixtureAttribute), false);
if (attributes == null || attributes.Length == 0) {
System.Diagnostics.Debug.Assert(!defined, "testing IsDefined equivalent [not]");
// Not a [TestFixture] class.
continue;
}
System.Diagnostics.Debug.Assert(defined, "testing IsDefined equivalent [is]");
if (type.IsNotPublic) {
//NUnit itself doesn't run on non-public classes!
continue;
}
if (type.IsAbstract) {
continue;
}
testTypes.Add(type);
}//for
#if ! FX1_1
return testTypes.ToArray();
#else
return (Type[])testTypes.ToArray(typeof(Type));
#endif
}
//----------------------------------------------------------------------
void InternalDoTestsOnClass(Type testFixtureType, StringBuilder timings)
{
Object instance = Activator.CreateInstance(testFixtureType);
// foreach method with attribute [Test], invoke,
// handling exception by checking if they're in a [ExcpectedException] attribute
//
MethodInfo[] methods = testFixtureType.GetMethods();
//----------
// [TestFixtureSetUpAttribute]
foreach (MethodInfo curMethod in methods) {
bool defined = curMethod.IsDefined(typeof(NUnit.Framework.TestFixtureSetUpAttribute), false);
object[] attributes = curMethod.GetCustomAttributes(typeof(NUnit.Framework.TestFixtureSetUpAttribute), false);
if (attributes == null || attributes.Length == 0) {
System.Diagnostics.Debug.Assert(!defined, "testing IsDefined equivalent [not]");
// Not [TestFixtureSetUp] method.
continue;
}
System.Diagnostics.Debug.Assert(defined, "testing IsDefined equivalent [not]");
try {
curMethod.Invoke(instance, null);
} catch (Exception ex) {
TheTestFailedByException(curMethod, ex);
goto exit;
}
}
//----------
foreach (MethodInfo curMethod in methods) {
if (m_userStopRequested) {
break;
}
bool defined = curMethod.IsDefined(typeof(NUnit.Framework.TestAttribute), false);
object[] attributes = curMethod.GetCustomAttributes(typeof(NUnit.Framework.TestAttribute), false);
if (attributes == null || attributes.Length == 0) {
System.Diagnostics.Debug.Assert(!defined, "testing IsDefined equivalent [not]");
// Not [Test] method.
continue;
}
System.Diagnostics.Debug.Assert(defined, "testing IsDefined equivalent [not]");
NUnit.Framework.ExpectedExceptionAttribute[] expctdExAttributes
= (NUnit.Framework.ExpectedExceptionAttribute[])
curMethod.GetCustomAttributes(
typeof(NUnit.Framework.ExpectedExceptionAttribute), false);
System.Diagnostics.Debug.Assert(expctdExAttributes.Length == 0
|| expctdExAttributes.Length == 1);
try {
object[] ignoreAttributes = curMethod.GetCustomAttributes(typeof(NUnit.Framework.IgnoreAttribute), false);
if (ignoreAttributes != null && ignoreAttributes.Length > 0) {
// [Ignore] test method.
System.Diagnostics.Debug.Assert(ignoreAttributes.Length == 1, "FAIL: attributes.Length == 1");
NUnit.Framework.IgnoreAttribute attr = (NUnit.Framework.IgnoreAttribute)ignoreAttributes[0];
throw new NUnit.Framework.IgnoreException(attr.Reason);
}
object[] explicitAttributes = curMethod.GetCustomAttributes(typeof(NUnit.Framework.ExplicitAttribute), false);
if (explicitAttributes != null && explicitAttributes.Length > 0) {
// [Explicit] test method.
System.Diagnostics.Debug.Assert(explicitAttributes.Length == 1, "FAIL: attributes.Length == 1");
continue;
}
//--------------------------------------------------
// Do it!!!!!!!
int startTickCount = Environment.TickCount;
curMethod.Invoke(instance, null);
int elapsed = Environment.TickCount - startTickCount;
const String Sep = ",";
timings.Append(testFixtureType.Name).Append(".");
timings.Append(curMethod.Name).Append(Sep);
timings.Append(elapsed).Append("\r\n");
if (expctdExAttributes != null && expctdExAttributes.Length > 0) {
/*Failed due to missing expected exception.*/
TheTestFailedByNotExpectedException(curMethod, expctdExAttributes);
continue;
}
TheTestPassed(curMethod);
// Done or thrown...
//--------------------------------------------------
} catch (NUnit.Framework.IgnoreException iex) {
TheTestNotRun(curMethod, iex.Message);
} catch (Exception testResultEx) {
if (expctdExAttributes != null && expctdExAttributes.Length > 0) {
NUnit.Framework.ExpectedExceptionAttribute expExAttr
= expctdExAttributes[0];
Type expExType = expExAttr.ExceptionType;
String expExName = expExAttr.ExceptionName;
if (testResultEx.GetType().Equals(expExType)) {
/* NOP Expected */
TheTestPassed(curMethod);
continue;
} else if (expExName != null
&& testResultEx.GetType().FullName.Equals(expExName)) {
// separate just now for initial testing; fold into the above...
/* NOP Expected */
TheTestPassed(curMethod);
continue;
}
}
// Otherwise unexpected!
TheTestFailedByException(curMethod, testResultEx);
}
}//for
//----------
// [TestFixtureTearDownAttribute]
foreach (MethodInfo curMethod in methods) {
bool defined = curMethod.IsDefined(typeof(NUnit.Framework.TestFixtureTearDownAttribute), false);
object[] attributes = curMethod.GetCustomAttributes(typeof(NUnit.Framework.TestFixtureTearDownAttribute), false);
if (attributes == null || attributes.Length == 0) {
System.Diagnostics.Debug.Assert(!defined, "testing IsDefined equivalent [not]");
// Not [TestFixtureSetUp] method.
continue;
}
System.Diagnostics.Debug.Assert(defined, "testing IsDefined equivalent [not]");
try{
curMethod.Invoke(instance, null);
} catch (Exception ex) {
TheTestFailedByException(curMethod, ex);
goto exit;
}
}
//----------
exit:
m_progressCountOfTestClasses++;
}
}//class
}
Reference in New Issue View Git Blame Copy Permalink