File: EventQueue.cs

package info (click to toggle)
mono 4.6.2.7+dfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 778,148 kB
  • ctags: 914,052
  • sloc: cs: 5,779,509; xml: 2,773,713; ansic: 432,645; sh: 14,749; makefile: 12,361; perl: 2,488; python: 1,434; cpp: 849; asm: 531; sql: 95; sed: 16; php: 1
file content (195 lines) | stat: -rw-r--r-- 3,674 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
// ****************************************************************
// Copyright 2007, Charlie Poole
// This is free software licensed under the NUnit license. You may
// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
// ****************************************************************
using System;
using System.Collections;
using System.Threading;

namespace NUnit.Core
{
	#region Individual Event Classes

	/// <summary>
	/// NUnit.Core.Event is the abstract base for all stored events.
	/// An Event is the stored representation of a call to the 
	/// EventListener interface and is used to record such calls
	/// or to queue them for forwarding on another thread or at
	/// a later time.
	/// </summary>
	public abstract class Event
	{
		abstract public void Send( EventListener listener );
	}

	public class RunStartedEvent : Event
	{
		string name;
		int testCount;

		public RunStartedEvent( string name, int testCount )
		{
			this.name = name;
			this.testCount = testCount;
		}

		public override void Send( EventListener listener )
		{
			listener.RunStarted(name, testCount);
		}
	}

	public class RunFinishedEvent : Event
	{
		TestResult result;
		Exception exception;

		public RunFinishedEvent( TestResult result )
		{
			this.result = result;
		}

		public RunFinishedEvent( Exception exception )
		{
			this.exception = exception;
		}

		public override void Send( EventListener listener )
		{
			if ( this.exception != null )
				listener.RunFinished( this.exception );
			else
				listener.RunFinished( this.result );
		}
	}

	public class TestStartedEvent : Event
	{
		TestName testName;

		public TestStartedEvent( TestName testName )
		{
			this.testName = testName;
		}

		public override void Send( EventListener listener )
		{
			listener.TestStarted( this.testName );
		}
	}
			
	public class TestFinishedEvent : Event
	{
		TestCaseResult result;

		public TestFinishedEvent( TestCaseResult result )
		{
			this.result = result;
		}

		public override void Send( EventListener listener )
		{
			listener.TestFinished( this.result );
		}
	}

	public class SuiteStartedEvent : Event
	{
		TestName suiteName;

		public SuiteStartedEvent( TestName suiteName )
		{
			this.suiteName = suiteName;
		}

		public override void Send( EventListener listener )
		{
			listener.SuiteStarted( this.suiteName );
		}
	}

	public class SuiteFinishedEvent : Event
	{
		TestSuiteResult result;

		public SuiteFinishedEvent( TestSuiteResult result )
		{
			this.result = result;
		}

		public override void Send( EventListener listener )
		{
			listener.SuiteFinished( this.result );
		}
	}

	public class UnhandledExceptionEvent : Event
	{
		Exception exception;

		public UnhandledExceptionEvent( Exception exception )
		{
			this.exception = exception;
		}

		public override void Send( EventListener listener )
		{
			listener.UnhandledException( this.exception );
		}
	}

	public class OutputEvent : Event
	{
		TestOutput output;

		public OutputEvent( TestOutput output )
		{
			this.output = output;
		}

		public override void Send( EventListener listener )
		{
			listener.TestOutput( this.output );
		}
	}

	#endregion

	/// <summary>
	/// Implements a queue of work items each of which
	/// is queued as a WaitCallback.
	/// </summary>
	public class EventQueue
	{
		private Queue queue = new Queue();

		public int Count
		{
			get 
			{
				lock( this )
				{
					return this.queue.Count; 
				}
			}
		}

		public void Enqueue( Event e )
		{
			lock( this )
			{
				this.queue.Enqueue( e );
				Monitor.Pulse( this );
			}
		}

		public Event Dequeue()
		{
			lock( this )
			{
				return (Event)this.queue.Dequeue();
			}
		}
	}
}