/// <summary>
/// Called when a test case is starting
/// </summary>
/// <param name="testName">The name of the test case</param>
public void TestStarted(TestName testName)
{
if (this.eventListener != null)
{
this.eventListener.TestStarted(testName);
}
}
public AggregatingTestRunner(int runnerID)
{
this.runnerID = runnerID;
this.testName = new TestName();
testName.TestID = new TestID(AggregateTestID);
testName.RunnerID = this.runnerID;
testName.FullName = testName.Name = "Not Loaded";
}
public void SetUp()
{
testCommand = MockRepository.GenerateStub<ITestCommand>();
testName = new TestName { TestID = new TestID(), FullName = "fullName" };
var testCommandsByTestName = new Dictionary<TestName, ITestCommand> { { testName, testCommand } };
testFilter = new NUnitTestFilter(testCommandsByTestName);
test = MockRepository.GenerateStub<ITest>();
}
/// <summary>
/// Constructs a test given its name
/// </summary>
/// <param name="name">The name of the test</param>
protected Test( string name )
{
this.testName = new TestName();
this.testName.FullName = name;
this.testName.Name = name;
this.testName.TestID = new TestID();
this.runState = RunState.Runnable;
}
/// <summary>
/// Constructs a test given the path through the
/// test hierarchy to its parent and a name.
/// </summary>
/// <param name="pathName">The parent tests full name</param>
/// <param name="name">The name of the test</param>
protected Test( string pathName, string name )
{
this.testName = new TestName();
this.testName.FullName = pathName == null || pathName == string.Empty
? name : pathName + "." + name;
this.testName.Name = name;
this.testName.TestID = new TestID();
this.runState = RunState.Runnable;
}
private TestResult BuildError(Exception e, TestConsoleAccess consoleAccess)
{
TestName testName = new TestName();
testName.Name = mPNUnitTestInfo.TestName;
testName.FullName = mPNUnitTestInfo.TestName;
testName.TestID = new TestID();
TestResult result = new PNUnitTestResult(testName, consoleAccess.GetTestOutput());
result.Error(e);
return result;
}
public void TestStarted(TestName testName)
{
TestCase ourCase = testConverter.GetCachedTestCase(testName.UniqueName);
// Simply ignore any TestName not found in the cache
if (ourCase != null)
{
this.testLog.RecordStart(ourCase);
// Output = testName.FullName + "\r";
}
}
/// <summary>
/// Construct from an ITest
/// </summary>
/// <param name="test">Test from which a TestNode is to be constructed</param>
public TestInfo( ITest test )
{
this.testName = (TestName)test.TestName.Clone();
this.testType = test.TestType;
this.runState = test.RunState;
this.ignoreReason = test.IgnoreReason;
this.description = test.Description;
this.isSuite = test.IsSuite;
if (test.Categories != null)
this.categories.AddRange(test.Categories);
if (test.Properties != null)
{
this.properties = new ListDictionary();
foreach( DictionaryEntry entry in test.Properties )
this.properties.Add( entry.Key, entry.Value );
}
this.testCaseCount = test.TestCount;
}
public static ITest MockTest(string name, ITest parentFixture)
{
var m = new Mock<ITest>();
var tn = new TestName
{
FullName = name,
Name = name
};
var ptn = new TestName
{
FullName = parentFixture.TestName.FullName,
Name = parentFixture.TestName.Name,
};
m.Setup(_ => _.TestName).Returns(tn);
m.Setup(_ => _.Parent.TestName).Returns(ptn);
m.Setup(_ => _.TestType).Returns("Test");
return m.Object;
}
public static ITest MockTestFixture(string name, string namespaceName)
{
var m = new Mock<ITest>();
var tn = new TestName
{
FullName = name,
Name = name
};
var ptn = new TestName
{
FullName = namespaceName,
Name = namespaceName
};
m.Setup(_ => _.TestName).Returns(tn);
m.Setup(_ => _.Parent.TestName).Returns(ptn);
m.Setup(_ => _.Tests).Returns(new ArrayList());
m.Setup(_ => _.TestType).Returns("TestFixture");
return m.Object;
}
void EventListener.SuiteStarted(TestName testName)
{
this.FireSuiteStarting(testName);
}
public void FireSuiteStarting( TestName testName )
{
Fire(
SuiteStarting,
new TestEventArgs( TestAction.SuiteStarting, testName ) );
}
public void FireTestStarting( TestName testName )
{
Fire(
TestStarting,
new TestEventArgs( TestAction.TestStarting, testName ) );
}
public void TestStarted( TestName testName )
{
//Debug.Log( "Running test " + testName.Name );
}
// TestStarting, SuiteStarting
public TestEventArgs( TestAction action, TestName testName )
{
Debug.Assert( action == TestAction.TestStarting || action == TestAction.SuiteStarting,
"Invalid TestAction argument to TestEventArgs constructor" );
this.action = action;
this.testName = testName;
}
/// <summary>
/// Construct a TestResult given a TestName
/// </summary>
/// <param name="testName">A TestName</param>
public TestResult(TestName testName)
: this(new TestInfo( testName ))
{
}
public void SuiteStarted(NUnit.Core.TestName testName)
{
}
public TestStartedEvent(TestName testName)
{
this.testName = testName;
}
/// <summary>
/// Construct a TestResult given a TestName
/// </summary>
/// <param name="testName">A TestName</param>
public TestResult(TestName testName) : this(new TestInfo(testName))
{
}
/// <summary>
/// Construct given a test name
/// </summary>
/// <param name="testName">The TestName for the new test</param>
public TestInfo(TestName testName) : this(testName, null)
{
}
/// <summary>
/// A single test case is starting
/// </summary>
/// <param name="testCase">The test case</param>
public void TestStarted(TestName testName)
{
events.Enqueue(new TestStartedEvent(testName));
}
void EventListener.TestStarted(TestName testName)
{
this.FireTestStarting( testName );
}
public void SuiteStarted(TestName testName)
{
if ( debugger && level++ == 0 )
{
testRunCount = 0;
testIgnoreCount = 0;
failureCount = 0;
Trace.WriteLine( "################################ UNIT TESTS ################################" );
Trace.WriteLine( "Running tests in '" + testName.FullName + "'..." );
}
}
public void TestStarted(TestName testName)
{
mPerfCollector.Collect(false, testName.FullName);
}
/// <summary>
/// Trigger event when each suite starts
/// </summary>
/// <param name="suite">Suite that is starting</param>
public void SuiteStarted(TestName suiteName)
{
events.FireSuiteStarting( suiteName );
}
/// <summary>
/// Constructs a test given a TestName object
/// </summary>
/// <param name="testName">The TestName for this test</param>
protected Test(TestName testName)
{
this.testName = testName;
this.runState = RunState.Runnable;
}
public void SuiteStarted(TestName testName)
{
}
public void SuiteStarted( TestName testName )
{
//Debug.Log( "Suite started:" + testName.Name );
}
public SuiteStartedEvent(TestName suiteName)
{
this.suiteName = suiteName;
}
public void TestStarted(NUnit.Core.TestName testName)
{
testRunnerEventListener.TestStarted(testName.FullName);
}
/// <summary>
/// A suite is starting
/// </summary>
/// <param name="suite">The suite that is starting</param>
public void SuiteStarted(TestName testName)
{
events.Enqueue(new SuiteStartedEvent(testName));
}
public void TestStarted(TestName testName)
{
currentTestName = testName.FullName;
// if ( options.labels )
// writer.WriteLine("***** {0}", testCase.FullName );
// else if ( !options.xmlConsole )
// Console.Write(".");
}
public void SuiteStarted(TestName testName)
{
log("{0} — START".Fmt(testName.FullName));
}
/// <summary>
/// Trigger event when each test starts
/// </summary>
/// <param name="testName">TestName of the Test that is starting</param>
public void TestStarted(TestName testName)
{
this.currentTestName = testName.FullName;
events.FireTestStarting( testName );
}
public void TestStarted(TestName testName)
{
log(" • {0}".Fmt(testName.Name));
}
public void TestStarted(TestName testName)
{
currentTestOutput = "";
}
public void TestStarted(TestName testName)
{
currentTestName = testName.FullName;
if ( options.labels )
outWriter.WriteLine("***** {0}", currentTestName );
if ( progress )
Console.Write(".");
}
public void TestStarted(TestName testName)
{
}
public void SuiteStarted(TestName testName)
{
if ( level++ == 0 )
{
messages = new StringCollection();
testRunCount = 0;
testIgnoreCount = 0;
failureCount = 0;
Trace.WriteLine( "################################ UNIT TESTS ################################" );
Trace.WriteLine( "Running tests in '" + testName.FullName + "'..." );
}
}
