public void CreateController()
{
#if PORTABLE || NETSTANDARD1_6
_controller = new FrameworkController(typeof(MockAssembly).GetTypeInfo().Assembly, "ID", _settings);
#else
_controller = new FrameworkController(MOCK_ASSEMBLY_PATH, "ID", _settings);
#endif
_handler = new CallbackEventHandler();
}
public void CreateController()
{
#if SILVERLIGHT
_controller = new FrameworkController(MOCK_ASSEMBLY_NAME, "ID", _settings);
#else
_controller = new FrameworkController(MOCK_ASSEMBLY_PATH, "ID", _settings);
#endif
_handler = new CallbackEventHandler();
}
private void ExploreTests(ICallbackEventHandler handler, string filter)
{
if (Runner.LoadedTest == null)
{
throw new InvalidOperationException("The Explore method was called but no test has been loaded");
}
handler.RaiseCallbackEvent(Runner.ExploreTests(TestFilter.FromXml(filter)).ToXml(true).OuterXml);
}
public void CreateController()
{
#if NETSTANDARD1_3 || NETSTANDARD1_6
_controller = new FrameworkController(typeof(MockAssembly).GetTypeInfo().Assembly, "ID", _settings);
#else
_controller = new FrameworkController(MOCK_ASSEMBLY_PATH, "ID", _settings);
#endif
_handler = new CallbackEventHandler();
}
public void CreateController()
{
#if PORTABLE
_controller = new FrameworkController(typeof(MockAssembly).GetTypeInfo().Assembly, "ID", _settings);
#elif SILVERLIGHT
_controller = new FrameworkController(MOCK_ASSEMBLY_NAME, "ID", _settings);
#else
_controller = new FrameworkController(MOCK_ASSEMBLY_PATH, "ID", _settings);
#endif
_handler = new CallbackEventHandler();
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
try
{
var count = Runner.CountTestCases(TestFilter.FromXml(filter));
handler.RaiseCallbackEvent(count.ToString());
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
static bool OnTestStart(ITestCommand command, ICallbackEventHandler callback)
{
if (callback == null)
return true;
XmlNode node = command.ToStartXml();
if (node != null)
callback.RaiseCallbackEvent(node.OuterXml);
return bool.Parse(callback.GetCallbackResult());
}
private void ExploreTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
if (Runner.LoadedTest == null)
{
throw new InvalidOperationException("The Explore method was called but no test has been loaded");
}
// TODO: Make use of the filter
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(true).OuterXml);
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
TNode result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter)).ToXml(true);
// Insert elements as first child in reverse order
if (Settings != null) // Some platforms don't have settings
{
InsertSettingsElement(result, Settings);
}
InsertEnvironmentElement(result);
handler.RaiseCallbackEvent(result.OuterXml);
}
private void LoadTests(ICallbackEventHandler handler)
{
if (_testAssembly != null)
{
Runner.Load(_testAssembly, Settings);
}
else
{
Runner.Load(AssemblyNameOrPath, Settings);
}
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(false).OuterXml);
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
if (Runner.LoadedTest == null)
{
throw new InvalidOperationException("The CountTests method was called but no test has been loaded");
}
var count = Runner.CountTestCases(TestFilter.FromXml(filter));
handler.RaiseCallbackEvent(count.ToString());
}
private void handleCallback()
{
// Get the UniqueID of the control.
// I have not tested this with controls put in INamingContainer.
// It may not work properly.
Control _control;
string controlUniqueID = Request["__CALLBACKID"];
if (controlUniqueID == "__PAGE")
{
_control = this;
}
else
{
_control = FindControl(controlUniqueID);
}
// Get the reference to the interface.
ICallbackEventHandler callbackHandler = _control as ICallbackEventHandler;
if (callbackHandler != null)
{
Response.Clear();
string result;
try
{
// Fire the callback handler method.
result = callbackHandler.RaiseClientCallbackEvent(Request["____CALLBACKPARAM"]);
// 's' for success.This will be further processed at client side.
Response.Write('s');
}
catch (Exception ex)
{
// 'e' for Exception.
Response.Write('e');
result = ex.Message;
}
// Write back to client.
Response.Write(result);
// Avoid any caching at client side.
Response.Cache.SetExpires(DateTime.Now);
Response.End();
}
}
static bool OnTestResult(ITestResult result, ICallbackEventHandler callback)
{
if (callback == null)
return true;
XmlDocument doc = new XmlDocument();
doc.LoadXml("<foo/>");
XmlNode node = result.ToXml(doc.ChildNodes[0]);
if (node != null)
callback.RaiseCallbackEvent(node.OuterXml);
return bool.Parse(callback.GetCallbackResult());
}
private void LoadTests(ICallbackEventHandler handler)
{
try
{
int count = Runner.Load(AssemblyPath, Settings)
? Runner.LoadedTest.TestCaseCount
: 0;
//TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(string.Format("<loaded assembly=\"{0}\" testcases=\"{1}\"/>", AssemblyPath, count));
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
private void ExploreTests(ICallbackEventHandler handler)
{
try
{
// TODO: Make use of the filter
if (Runner.Load(AssemblyPath, Settings))
{
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(true).OuterXml);
}
else
{
handler.RaiseCallbackEvent(FormatErrorReport("No tests were found"));
}
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
try
{
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
finally
{
//InternalTrace.Flush();
}
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
TNode result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter)).ToXml(true);
// Insert elements as first child in reverse order
if (Settings != null) // Some platforms don't have settings
{
InsertSettingsElement(result, Settings);
}
#if !PORTABLE && !SILVERLIGHT
InsertEnvironmentElement(result);
#endif
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.OuterXml);
}
public void CreateController()
{
_mockAssemblyPath = Path.Combine(TestContext.CurrentContext.TestDirectory, MOCK_ASSEMBLY);
_controller = new FrameworkController(_mockAssemblyPath, _settings);
_handler = new CallbackEventHandler();
}
public void CreateController()
{
_controller = new FrameworkController(MOCK_ASSEMBLY_PATH, "ID", _settings);
_handler = new CallbackEventHandler();
}
public void CreateDriver()
{
_mockAssemblyPath = PathUtils.Combine(TestContext.CurrentContext.TestDirectory, MOCK_ASSEMBLY);
_driver = new NUnitFrameworkDriver(AppDomain.CurrentDomain, _mockAssemblyPath, _settings);
_handler = new CallbackEventHandler();
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
TNode result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter)).ToXml(true);
// Insert elements as first child in reverse order
if (Settings != null) // Some platforms don't have settings
InsertSettingsElement(result, Settings);
#if !PORTABLE && !SILVERLIGHT
InsertEnvironmentElement(result);
#endif
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.OuterXml);
}
private void StopRun(ICallbackEventHandler handler, bool force)
{
StopRun(force);
}
void ProcessRaiseCallbackEvent (ICallbackEventHandler target, ref string callbackEventError)
{
string callbackArgument = _requestValueCollection [CallbackArgumentID];
try {
target.RaiseCallbackEvent (callbackArgument);
} catch (Exception ex) {
callbackEventError = String.Concat ("e", RuntimeHelpers.DebuggingEnabled ? ex.ToString () : ex.Message);
}
}
private void LoadTests(ICallbackEventHandler handler)
{
handler.RaiseCallbackEvent(LoadTests());
}
public void CreateDriver()
{
_mockAssemblyPath = PathUtils.Combine(TestContext.CurrentContext.TestDirectory, MOCK_ASSEMBLY);
_driver = new NUnitFrameworkDriver(AppDomain.CurrentDomain, _mockAssemblyPath, _settings);
_handler = new CallbackEventHandler();
}
/// <inheritdoc/>
public void EnumerateTests(ICallbackEventHandler handler)
{
CreateObject("Xunit.Sdk.Executor+EnumerateTests", executor, handler);
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
var count = Runner.CountTestCases(TestFilter.FromXml(filter));
handler.RaiseCallbackEvent(count.ToString());
}
private void LoadTests(ICallbackEventHandler handler)
{
if (_testAssembly != null)
Runner.Load(_testAssembly, Settings);
else
Runner.Load(AssemblyNameOrPath, Settings);
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(false).OuterXml);
}
/// <inheritdoc/>
public void RunTests(string type, List<string> methods, ICallbackEventHandler handler)
{
CreateObject("Xunit.Sdk.Executor+RunTests", executor, type, methods, handler);
}
/// <inheritdoc/>
public void EnumerateTests(ICallbackEventHandler handler)
{
CreateObject("Xunit.Sdk.Executor+EnumerateTests", executor, handler);
}
private void RunTests(ICallbackEventHandler handler, string filter)
{
try
{
ITestResult result = Runner.Run(new TestProgressReporter(handler), TestFilter.FromXml(filter));
// Ensure that the CallContext of the thread is not polluted
// by our TestExecutionContext, which is not serializable.
TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(result.ToXml(true).OuterXml);
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
finally
{
//InternalTrace.Flush();
}
}
private void LoadTests(ICallbackEventHandler handler)
{
Runner.Load(AssemblyPath, Settings);
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(false).OuterXml);
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
try
{
var count = Runner.CountTestCases(TestFilter.FromXml(filter));
handler.RaiseCallbackEvent(count.ToString());
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TestProgressReporter"/> class.
/// </summary>
/// <param name="handler">The callback handler to be used for reporting progress.</param>
public TestProgressReporter(ICallbackEventHandler handler)
{
this.handler = handler;
}
string ProcessGetCallbackResult (ICallbackEventHandler target, string callbackEventError)
{
string callBackResult;
try {
callBackResult = target.GetCallbackResult ();
} catch (Exception ex) {
return String.Concat ("e", RuntimeHelpers.DebuggingEnabled ? ex.ToString () : ex.Message);
}
string eventValidation = ClientScript.GetEventValidationStateFormatted ();
return callbackEventError + (eventValidation == null ? "0" : eventValidation.Length.ToString ()) + "|" +
eventValidation + callBackResult;
}
private void RunAsync(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
Runner.RunAsync(new TestProgressReporter(handler), TestFilter.FromXml(filter));
}
private void ExploreTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
if (Runner.LoadedTest == null)
throw new InvalidOperationException("The Explore method was called but no test has been loaded");
// TODO: Make use of the filter
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(true).OuterXml);
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
handler.RaiseCallbackEvent(CountTests(filter).ToString());
}
private void RunAsync(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
Runner.RunAsync(new TestProgressReporter(handler), TestFilter.FromXml(filter));
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
Guard.ArgumentNotNull(filter, "filter");
if (Runner.LoadedTest == null)
throw new InvalidOperationException("The CountTests method was called but no test has been loaded");
var count = Runner.CountTestCases(TestFilter.FromXml(filter));
handler.RaiseCallbackEvent(count.ToString());
}
private void CountTests(ICallbackEventHandler handler, string filter)
{
handler.RaiseCallbackEvent(CountTests(filter).ToString());
}
private void LoadTests(ICallbackEventHandler handler)
{
try
{
int count = Runner.Load(AssemblyPath, Settings)
? Runner.LoadedTest.TestCaseCount
: 0;
//TestExecutionContext.ClearCurrentContext();
handler.RaiseCallbackEvent(string.Format("<loaded assembly=\"{0}\" testcases=\"{1}\"/>", AssemblyPath, count));
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
private void LoadTests(ICallbackEventHandler handler)
{
handler.RaiseCallbackEvent(LoadTests());
}
private void ExploreTests(ICallbackEventHandler handler)
{
try
{
// TODO: Make use of the filter
if (Runner.Load(AssemblyPath, Settings))
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(true).OuterXml);
else
handler.RaiseCallbackEvent(FormatErrorReport("No tests were found"));
}
catch (Exception ex)
{
handler.RaiseCallbackEvent(FormatErrorReport(ex));
}
}
private void LoadTests(ICallbackEventHandler handler)
{
Runner.Load(AssemblyPath, Settings);
handler.RaiseCallbackEvent(Runner.LoadedTest.ToXml(false).OuterXml);
}
private void PrepareCallback(string callbackControlID)
{
this.Response.Cache.SetNoStore();
try
{
string eventArgument = this._requestValueCollection["__CALLBACKPARAM"];
this._callbackControl = this.FindControl(callbackControlID) as ICallbackEventHandler;
if (this._callbackControl == null)
{
throw new InvalidOperationException(System.Web.SR.GetString("Page_CallBackTargetInvalid", new object[] { callbackControlID }));
}
this._callbackControl.RaiseCallbackEvent(eventArgument);
}
catch (Exception exception)
{
this.Response.Clear();
this.Response.Write('e');
if (this.Context.IsCustomErrorEnabled)
{
this.Response.Write(System.Web.SR.GetString("Page_CallBackError"));
}
else
{
bool flag = !string.IsNullOrEmpty(this._requestValueCollection["__CALLBACKLOADSCRIPT"]);
this.Response.Write(flag ? System.Web.UI.Util.QuoteJScriptString(HttpUtility.HtmlEncode(exception.Message)) : HttpUtility.HtmlEncode(exception.Message));
}
}
}
private void StopRun(ICallbackEventHandler handler, bool force)
{
StopRun(force);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestProgressReporter"/> class.
/// </summary>
/// <param name="handler">The callback handler to be used for reporting progress.</param>
public TestProgressReporter(ICallbackEventHandler handler)
{
this.handler = handler;
}
public void CreateController()
{
_mockAssemblyPath = Path.Combine(TestContext.CurrentContext.TestDirectory, MOCK_ASSEMBLY);
_controller = new FrameworkController(_mockAssemblyPath, _settings);
_handler = new CallbackEventHandler();
}
private void ExploreTests(ICallbackEventHandler handler, string filter)
{
handler.RaiseCallbackEvent(ExploreTests(filter));
}
/// <inheritdoc/>
public void RunTests(string type, List <string> methods, ICallbackEventHandler handler)
{
CreateObject("Xunit.Sdk.Executor+RunTests", executor, type, methods, handler);
}
private void RunAsync(ICallbackEventHandler handler, string filter)
{
Runner.RunAsync(new TestProgressReporter(handler), TestFilter.FromXml(filter));
}
