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;
        }
Example #6
0
        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);
            }
        }
Example #7
0
        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);
        }
Example #9
0
		public override TestResult Run(EventListener listener, ITestFilter filter)
		{
			if (this.Parent != null)
				this.Fixture = this.Parent.Fixture;
			
			return base.Run(listener, filter);
		}
Example #10
0
		public override void Send( EventListener listener )
		{
			if ( this.exception != null )
				listener.RunFinished( this.exception );
			else
				listener.RunFinished( this.result );
		}
Example #11
0
        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;
        }
Example #12
0
        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 ();
            }
        }
Example #13
0
		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;
        }
Example #16
0
        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;
            }
        }
Example #17
0
        public override void RemoveAllIncompleteListeners()
        {
            EventTracker.RemoveListener(mListener);
            mListener = null;

            base.RemoveAllIncompleteListeners();
        }
Example #18
0
        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);
        }
Example #19
0
		/// <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;
        }
Example #22
0
		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;
        }
Example #24
0
        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;
 }
Example #27
0
 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);
     }
 }
Example #28
0
 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);
        }
Example #31
0
 public FairyFieldProxy(object target, IProxyFieldInfo fieldInfo, EventListener listener) : base(target, fieldInfo)
 {
     this.listener = listener;
 }
Example #32
0
 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);
 }
Example #34
0
 public void RemoveEventListener(HashChangeEventType type, EventListener <HashChangeEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #35
0
 public void RemoveEventListener(PageTransitionEventType type, EventListener <PageTransitionEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #36
0
 private void ModifyConfig(IEnumerable <string> featureFiles, IEnumerable <string> assemblies, EventListener eventListener)
 {
     config
     .SetAssemblies(assemblies)
     .SetEventListener(eventListener)
     .SetScenarioFiles(featureFiles);
 }
Example #37
0
 /// <summary> GameObject 点击事件,带返回参数,点击点数据</summary>
 public static void AddClick(this GameObject go, PointerDataArgDelegate action, object arg = null)
 {
     EventListener.Get(go).onClick = (data) => { action(arg, data); };
 }
Example #38
0
 public void AddEventListener(StorageEventType type, EventListener <StorageEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #39
0
 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);
 }
Example #42
0
 public void AddEventListener(AudioContextEventType type, EventListener <AudioContextEvent> listener, bool useCapture = false)
 {
 }
Example #43
0
 public void RemoveEventListener(MessageEventType type, EventListener <MessageEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #44
0
 /// <summary>
 /// Add the event listener to the list of listeners
 /// </summary>
 public void Register(EventListener eventListener)
 {
     m_eventListeners.Add(eventListener);
 }
Example #45
0
 public void RemoveEventListener(PopStateEventType type, EventListener <PopStateEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #46
0
 /// <summary>
 /// Remove the event listener from the list of listeners
 /// </summary>
 /// <param name="eventListener"></param>
 public void Unregister(EventListener eventListener)
 {
     m_eventListeners.Remove(eventListener);
 }
Example #47
0
 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);
 }
Example #49
0
 public void AddEventListener(DeviceMotionEventType type, EventListener <DeviceMotionEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #50
0
 public void RemoveEventListener(DeviceOrientationEventType type, EventListener <DeviceOrientationEvent <Window> > listener, bool useCapture = false)
 {
 }
Example #51
0
 public void Initialize()
 {
     _eventAdapter = new TestEventAdapter(this);
     _report       = null;
 }
Example #52
0
 public new static int EventSourceIndex(EventSource eventSource)
 {
     return(EventListener.EventSourceIndex(eventSource));
 }
Example #53
0
 /// <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); };
 }
Example #54
0
 /// <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)
 {
 }
Example #56
0
    //=========================================================

    /// <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)
 {
 }
Example #60
0
 /// <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); };
 }