TestResult RunTest(EventListener listener) { listener.TestStarted(base.TestName); TestResult nunitTestResult = new TestResult(this); if (_pendingException != null) { nunitTestResult.Failure(_pendingException.Message, _pendingException.StackTrace, FailureSite.Test); } else if (RunState == RunState.NotRunnable) { nunitTestResult.SetResult(ResultState.NotRunnable, IgnoreReason, "", FailureSite.Test); } else { var testResult = SpecificationRunner.RunTest(this._testContext, new List<string>()); NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult); } listener.TestFinished(nunitTestResult); return nunitTestResult; }
public Scene(Camera2D camera, EventListener listener = null) { this.root = new Actor(); this.root.SetScene(this); this.camera = camera; this.listener = listener; }
public void SetUp() { _Un = new MyObject("a", 0); _Deux = new MyObject("b", 1); _Trois = new MyObject("c", 2); _Quatre = new MyObject("d", 3); _Cinq = new MyObject("e", 4); _DecoratedOriginalElements = new List<MyObject>(); _DecoratedOriginalElements.Add(_Un); _DecoratedOriginalElements.Add(_Deux); _DecoratedOriginalElements.Add(_Trois); _DecoratedOriginalElements.Add(_Quatre); _DecoratedOriginalElements.Add(_Cinq); _ListForComparison = new List<IObject>(); _ListForComparison.AddRange(_DecoratedOriginalElements); _OriginalElements = new List<MyObject>(); _OriginalElements.AddRange(_DecoratedOriginalElements); _SCMC = SafeCollectionModifierConverter<MyObject, IObject>.GetSafeCollectionModifierConverterDerived<MyObject, IObject>(_DecoratedOriginalElements); _IML = _SCMC; _ChangedList = _IML.MofifiableCollection; _EL = new EventListener<EventArgs>(); _SCMC.OnCommit += _EL.SingleElementChangedListener; }
public TestResult Run(EventListener listener, IFilter filter, string path, string suiteName, string testName) { TestSuite rootTS = LoadTestSuite (path, suiteName); TextWriter origStdout = Console.Out; TextWriter origStderr = Console.Error; Console.SetOut (stdout); Console.SetError (stderr); string cdir = Environment.CurrentDirectory; Environment.CurrentDirectory = Path.GetDirectoryName (path); try { Test nt = null; if (testName != null) { foreach (Test t in rootTS.Tests) if (t.Name == testName) { nt = t; break; } } else nt = rootTS; if (nt == null) throw new Exception ("Test " + suiteName + "." + testName + " not found."); return nt.Run (listener, filter); } finally { Environment.CurrentDirectory = cdir; Console.SetOut (origStdout); Console.SetError (origStderr); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { test.Parent = Parent; TestResult result = null; for (var i = 1; i < retryCount; i++) { try { result = test.Run(listener, filter); if (result.IsFailure || result.IsError) { var message = string.Format("Rerunning '{0}'", TestName); Log.Info(message); Console.WriteLine(message); result = test.Run(listener, filter); } } // In Case SetUp or TearDown failed catch (Exception e) { Log.Info(e.Message); Console.WriteLine(e); } } return result; }
public void Unregister(object owner, string type, EventListener listener) { Log.Assert(owner != null); Log.Assert(type != null); Log.Assert(listener != null); if (listeners.ContainsKey(type)) { listeners[type] -= listener; if (listeners[type] == null) listeners.Remove(type); List<ListenerInfo> infos = owners[owner]; for (int i = infos.Count - 1; i >= 0; --i) { ListenerInfo info = infos[i]; if (info.type == type && info.listener == listener) { infos.Remove(info); break; } } if (infos.Count == 0) owners.Remove(owner); } }
public void AddEventListener( string namespaceUri, string eventType, object eventGroup, EventListener listener) { EventListenerMapEntry[] entries = GrowBy(1); for (int i = 0; i < count; i++) { if (namespaceUri != entries[i].NamespaceUri) { continue; } if (eventType != entries[i].Type) { continue; } if (listener == entries[i].Listener) { return; } } entries[count] = new EventListenerMapEntry( namespaceUri, eventType, eventGroup, listener, locked); count++; }
void IEventTarget.RemoveEventListener( string type, EventListener listener, bool useCapture) { eventTarget.RemoveEventListener(type, listener, useCapture); }
public override TestResult Run(EventListener listener, ITestFilter filter) { if (this.Parent != null) this.Fixture = this.Parent.Fixture; return base.Run(listener, filter); }
public override void Send( EventListener listener ) { if ( this.exception != null ) listener.RunFinished( this.exception ); else listener.RunFinished( this.result ); }
public override TestResult Run(EventListener listener, ITestFilter filter) { var successCount = 0; TestResult failureResult = null; for (var i = 0; i < this.tryCount; i++) { var result = base.Run(listener, filter); if (!TestFailed(result)) { if (i == 0) { return result; } if (++successCount >= this.requiredPassCount) { return result; } } else { failureResult = result; } } return failureResult; }
public override TestResult Run(EventListener listener, ITestFilter filter) { TestSuiteResult suite_result = new TestSuiteResult (new TestInfo (this), TestName.FullName); DebuggerTestHost host = DebuggerTestHost.Create (); if (host == null) { TestCaseResult error = new TestCaseResult (new TestInfo (this)); string msg = String.Format ("Failed to create DebuggerTestHost in {0}", FixtureType.Name); error.Failure (msg, null, FailureSite.Parent); suite_result.AddResult (error); return suite_result; } int timeout; if (Attribute.Timeout != 0) timeout = Attribute.Timeout; else timeout = DebuggerTestAddIn.DefaultTimeout; int repeat = 1; if (Attribute.Repeat != 0) repeat = Attribute.Repeat; try { for (int i = 0; i < repeat; i++) { if (!host.Run (new TestInfo (this), suite_result, Type.AssemblyQualifiedName, listener, filter, timeout)) break; } return suite_result; } finally { host.Dispose (); } }
public TestResult Run (EventListener listener, ITestFilter filter, string path, string suiteName, List<string> supportAssemblies, string testRunnerType, string testRunnerAssembly) { InitSupportAssemblies (supportAssemblies); if (filter == null) filter = TestFilter.Empty; TestRunner tr; if (!string.IsNullOrEmpty (testRunnerType)) { Type runnerType; if (string.IsNullOrEmpty (testRunnerAssembly)) runnerType = Type.GetType (testRunnerType, true); else { var asm = Assembly.LoadFrom (testRunnerAssembly); runnerType = asm.GetType (testRunnerType); } tr = (TestRunner)Activator.CreateInstance (runnerType); } else tr = new RemoteTestRunner (); TestPackage package = new TestPackage (path); if (!string.IsNullOrEmpty (suiteName)) package.TestName = suiteName; tr.Load (package); return tr.Run (listener, filter, false, LoggingThreshold.All); }
public override TestResult Run(EventListener listener, ITestFilter filter) { using ( new DirectorySwapper( Path.GetDirectoryName( TestFixtureBuilder.GetAssemblyPath( FixtureType ) ) ) ) { return base.Run(listener, filter); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { listener.SuiteStarted(this.TestName); var suiteListener = new MuteSuiteListener(listener); var fixtureResult = base.Run(suiteListener, TestFilter.Empty); var testResult = fixtureResult.Results[0] as TestResult; if (testResult != null) { if (testResult.IsFailure || testResult.IsError) { fixtureResult.SetResult(testResult.ResultState, testResult.Message, testResult.StackTrace); } if (testResult.IsSuccess) { fixtureResult.Success(); } } listener.SuiteFinished(fixtureResult); return fixtureResult; }
public override TestResult Run(EventListener listener, ITestFilter filter) { using (new global::NUnit.Core.TestContext()) { var testResult = new TestResult(this); Log.Debug("Test Starting: " + TestName.FullName); listener.TestStarted(TestName); var stopwatch = new Stopwatch(); stopwatch.Start(); switch (RunState) { case RunState.Runnable: case RunState.Explicit: DoTest(_test, testResult); break; case RunState.NotRunnable: testResult.Invalid(IgnoreReason); break; case RunState.Ignored: testResult.Ignore(IgnoreReason); break; default: testResult.Skip(IgnoreReason); break; } stopwatch.Stop(); testResult.Time = stopwatch.Elapsed.Seconds; listener.TestFinished(testResult); return testResult; } }
public override void RemoveAllIncompleteListeners() { EventTracker.RemoveListener(mListener); mListener = null; base.RemoveAllIncompleteListeners(); }
public Level(EventListener sysCall, StaticData sdb, ViewDB vdb, Viewport view) { disp = new EventDispatcher(); state = new State(sdb); op = new Operator(); gui = new GUI(vdb, view, op.OnSelect, disp); disp.MapInput(InputType.MouseLeft_Up, EventType.Select); disp.MapInput(InputType.MouseRight_Up, EventType.Action); disp.MapInput(InputType.RightShift_Down, EventType.Waypoint); disp.MapInput(InputType.RightShift_Up, EventType.WaypointOff); disp.MapInput(InputType.LeftShift_Down, EventType.Waypoint); disp.MapInput(InputType.LeftShift_Up, EventType.WaypointOff); disp.MapInput(InputType.Up_Down, EventType.CameraUp); disp.MapInput(InputType.Right_Down, EventType.CameraRight); disp.MapInput(InputType.Down_Down, EventType.CameraDown); disp.MapInput(InputType.Left_Down, EventType.CameraLeft); disp.MapInput(InputType.Up_Up, EventType.CameraUpEnd); disp.MapInput(InputType.Right_Up, EventType.CameraRightEnd); disp.MapInput(InputType.Down_Up, EventType.CameraDownEnd); disp.MapInput(InputType.Left_Up, EventType.CameraLeftEnd); disp.MapInput(InputType.Escape_Up, EventType.End); disp.AddListener(this, EventType.Game); disp.AddListener(sysCall, EventType.System); }
/// <summary> /// Constructor /// </summary> /// <param name="eventListener">The EventListener to receive events</param> /// <param name="events">The event queue to pull events from</param> /// <param name="autostop">Set to true to stop pump after RunFinished</param> public EventPump( EventListener eventListener, EventQueue events, bool autostop) { this.eventListener = eventListener; this.events = events; this.events.SetWaitHandleForSynchronizedEvents(this.synchronousEventSent); this.autostop = autostop; }
public override TestResult Run( EventListener listener ) { using( new TestContext() ) { TestCaseResult testResult = MakeTestCaseResult(); listener.TestStarted( this.TestName ); long startTime = DateTime.Now.Ticks; switch (this.RunState) { case RunState.Runnable: case RunState.Explicit: Run(testResult); break; case RunState.Skipped: testResult.Skip(IgnoreReason); break; default: case RunState.NotRunnable: case RunState.Ignored: testResult.Ignore(IgnoreReason); break; } long stopTime = DateTime.Now.Ticks; double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond; testResult.Time = time; listener.TestFinished(testResult); return testResult; } }
public override TestResult Run(EventListener listener, ITestFilter filter) { listener.TestStarted(base.TestName); long ticks = DateTime.Now.Ticks; var testResult = new TestResultShim(); Exception existingError = null; _globalSetup.PrepareForTestPosition(Position, out existingError); if (existingError != null) { TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), existingError, null, TestResultShim.Site.SetUp); } else { List<string> traceMessages = null; try { RunTestMethod(testResult, out traceMessages); } catch (Exception e) { var globalTraceMessages = _globalSetup.GetTraceMessages(); TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), e, globalTraceMessages.Concat(traceMessages)); } } var nunitTestResult = new TestResult(this); NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult); nunitTestResult.Time = ((DateTime.Now.Ticks - ticks)) / 10000000.0; listener.TestFinished(nunitTestResult); return nunitTestResult; }
public override TestResult Run(EventListener listener, ITestFilter filter) { using ( new DirectorySwapper( AssemblyHelper.GetDirectoryName( FixtureType.Assembly ) ) ) { return base.Run(listener, filter); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { listener.TestStarted(base.TestName); long ticks = DateTime.Now.Ticks; TestResult testResult = new TestResult(this); Exception existingError = null; _globalSetup.PrepareForTestPosition(Position, out existingError); if (existingError != null) { TestResultUtil.Error(testResult, existingError, null, FailureSite.SetUp); } else { List<string> traceMessages = null; try { RunTestMethod(testResult, out traceMessages); } catch (Exception e) { var globalTraceMessages = _globalSetup.GetTraceMessages(); TestResultUtil.Error(testResult, e, globalTraceMessages.Concat(traceMessages)); } } double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0; testResult.Time = num3; listener.TestFinished(testResult); return testResult; }
public override TestResult Run(EventListener listener, ITestFilter filter) { var result = new TestResult(this); lock (testClosure) { try { testClosure.TestMethod(); TestNonExceptionCondition(result); } catch (IgnoreException iex) { result.Ignore(iex.Message); } catch (InconclusiveException icex) { result.Invalid(icex.Message); } catch (Exception ex) { TestExceptionCondition(result, ex); } try { testClosure.TearDown(); } catch (Exception ex) { result.Failure("Exception in tear-down: "+ex.Message, ex.StackTrace); } } listener.TestFinished(result); return result; }
/// <summary> /// Override Run, setting Fixture to that of the Parent. /// </summary> /// <param name="listener"></param> /// <param name="filter"></param> /// <returns></returns> public override TestResult Run(EventListener listener, ITestFilter filter) { if (this.Parent != null) { this.Fixture = this.Parent.Fixture; TestSuite suite = this.Parent as TestSuite; if (suite != null) { this.setUpMethods = suite.GetSetUpMethods(); this.tearDownMethods = suite.GetTearDownMethods(); } } // DYNAMIC: Get the parameters, and add the methods here. TestResult result = base.Run(listener, filter); if (this.isTheory && result.ResultState == ResultState.Inconclusive) result.SetResult( ResultState.Failure, this.TestCount == 0 ? "No test cases were provided" : "All test cases were inconclusive", null); this.Fixture = null; this.setUpMethods = null; this.tearDownMethods = null; return result; }
public static void Main() { Student oneStu = new Student(); EventListener listener = new EventListener(oneStu); oneStu.IdNum = 2345; oneStu.IdNum = 4567; oneStu.Gpa = 3.2; }
public static void AddListener(EventListener listener) { if (!Listeners.Contains (listener)) { Listeners.Add(listener); if (Bugger.WillLog (RMXTests.EventCenter, listener.GetType () + " was added to Listeners (" + Listeners.Count + ")")) Debug.Log (Bugger.Last); } }
public override TestResult Run(EventListener listener, ITestFilter filter) { Uri uri = new Uri( FixtureType.Assembly.CodeBase ); using ( new DirectorySwapper( Path.GetDirectoryName( uri.LocalPath ) ) ) { return base.Run(listener, filter); } }
public void removeListener(EventListener listener) { if (dispactchingLevel > 0) { listener.markDeleted (); } else { listeners.Remove(listener); } }
void IEventTarget.RemoveEventListenerNs( string namespaceUri, string type, EventListener listener, bool useCapture) { eventTarget.RemoveEventListenerNs(namespaceUri, type, listener, useCapture); }
public FairyFieldProxy(object target, IProxyFieldInfo fieldInfo, EventListener listener) : base(target, fieldInfo) { this.listener = listener; }
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel) { // Save active listener for derived classes this.listener = listener; return(this.testRunner.Run(listener, filter, tracing, logLevel)); }
void IEventTarget.AddEventListenerNs(string namespaceUri, string type, EventListener listener, bool useCapture, object eventGroup) { eventTarget.AddEventListenerNs(namespaceUri, type, listener, useCapture, eventGroup); }
public void RemoveEventListener(HashChangeEventType type, EventListener <HashChangeEvent <Window> > listener, bool useCapture = false) { }
public void RemoveEventListener(PageTransitionEventType type, EventListener <PageTransitionEvent <Window> > listener, bool useCapture = false) { }
private void ModifyConfig(IEnumerable <string> featureFiles, IEnumerable <string> assemblies, EventListener eventListener) { config .SetAssemblies(assemblies) .SetEventListener(eventListener) .SetScenarioFiles(featureFiles); }
/// <summary> GameObject 点击事件,带返回参数,点击点数据</summary> public static void AddClick(this GameObject go, PointerDataArgDelegate action, object arg = null) { EventListener.Get(go).onClick = (data) => { action(arg, data); }; }
public void AddEventListener(StorageEventType type, EventListener <StorageEvent <Window> > listener, bool useCapture = false) { }
public virtual void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel) { // Save active listener for derived classes this.listener = listener; this.testRunner.BeginRun(listener, filter, tracing, logLevel); }
public void RemoveEventListener(ApplicationCacheEventType type, EventListener <ApplicationCacheEvent> listener, bool useCapture = false) { }
void IEventTarget.RemoveEventListenerNs(string namespaceUri, string type, EventListener listener, bool useCapture) { eventTarget.RemoveEventListenerNs(namespaceUri, type, listener, useCapture); }
public void AddEventListener(AudioContextEventType type, EventListener <AudioContextEvent> listener, bool useCapture = false) { }
public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <Window> > listener, bool useCapture = false) { }
/// <summary> /// Add the event listener to the list of listeners /// </summary> public void Register(EventListener eventListener) { m_eventListeners.Add(eventListener); }
public void RemoveEventListener(PopStateEventType type, EventListener <PopStateEvent <Window> > listener, bool useCapture = false) { }
/// <summary> /// Remove the event listener from the list of listeners /// </summary> /// <param name="eventListener"></param> public void Unregister(EventListener eventListener) { m_eventListeners.Remove(eventListener); }
public override TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel) { BeginRun(listener, filter, tracing, logLevel); return(EndRun()); }
void IEventTarget.RemoveEventListener(string type, EventListener listener, bool useCapture) { eventTarget.RemoveEventListener(type, listener, useCapture); }
public void AddEventListener(DeviceMotionEventType type, EventListener <DeviceMotionEvent <Window> > listener, bool useCapture = false) { }
public void RemoveEventListener(DeviceOrientationEventType type, EventListener <DeviceOrientationEvent <Window> > listener, bool useCapture = false) { }
public void Initialize() { _eventAdapter = new TestEventAdapter(this); _report = null; }
public new static int EventSourceIndex(EventSource eventSource) { return(EventListener.EventSourceIndex(eventSource)); }
/// <summary> 控件点击事件</summary> public static void AddClick <T, T1, T2>(this T go, Action <T1, T2> action, T1 arg1, T2 arg2) where T : Component { EventListener.Get(go).onClick = (data) => { action(arg1, arg2); }; }
/// <summary> 控件点击事件</summary> public static void AddClick <T>(this T go, PointerDataArgDelegate action, object arg = null) where T : Component { EventListener.Get(go).onClick = (data) => { action(arg, data); }; }
public void RemoveEventListener(ErrorEventType type, EventListener <ErrorEvent <DOMApplicationCache, DOMApplicationCache> > listener, bool useCapture = false) { }
//========================================================= /// <summary> 控件点击事件</summary> public static void AddClick <T>(this T go, Action action) where T : Component { EventListener.Get(go).onClick = (data) => { action(); }; }
public new void RemoveEventListener(JsString type, EventListener listener, bool useCapture = false) { }
public void RemoveEventListener(ProgressEventType type, EventListener <ProgressEvent> listener, bool useCapture = false) { }
public void AddEventListener(ProgressEventType type, EventListener <ProgressEvent <DOMApplicationCache, DOMApplicationCache> > listener, bool useCapture = false) { }
/// <summary> GameObject 点击事件,带2参数</summary> public static void AddClick <T1, T2>(this GameObject go, Action <T1, T2> action, T1 arg1, T2 arg2) { EventListener.Get(go).onClick = (data) => { action(arg1, arg2); }; }