← Back to branch summary

~nunit-core/nunitv2/2.5

« back to all changes in this revision

Viewing changes to src/NUnitCore/core/TestResult.cs

  • Committer: charliepoole
  • Date: 2006-01-06 01:08:17 UTC
  • Revision ID: vcs-imports@canonical.com-20060106010817-z6xazs4kd89zj8j1
Move core from under NUnitFramework to NUnitCore directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/NUnitCore/core/TestResult.cs
 
1
#region Copyright (c) 2002-2003, James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole, Philip A. Craig
 
2
/************************************************************************************
 
3
'
 
4
' Copyright � 2002-2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
 
5
' Copyright � 2000-2003 Philip A. Craig
 
6
'
 
7
' This software is provided 'as-is', without any express or implied warranty. In no 
 
8
' event will the authors be held liable for any damages arising from the use of this 
 
9
' software.
 
10
' 
 
11
' Permission is granted to anyone to use this software for any purpose, including 
 
12
' commercial applications, and to alter it and redistribute it freely, subject to the 
 
13
' following restrictions:
 
14
'
 
15
' 1. The origin of this software must not be misrepresented; you must not claim that 
 
16
' you wrote the original software. If you use this software in a product, an 
 
17
' acknowledgment (see the following) in the product documentation is required.
 
18
'
 
19
' Portions Copyright � 2003 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole
 
20
' or Copyright � 2000-2003 Philip A. Craig
 
21
'
 
22
' 2. Altered source versions must be plainly marked as such, and must not be 
 
23
' misrepresented as being the original software.
 
24
'
 
25
' 3. This notice may not be removed or altered from any source distribution.
 
26
'
 
27
'***********************************************************************************/
 
28
#endregion
 
29
 
 
30
namespace NUnit.Core
 
31
{
 
32
        using System;
 
33
        using System.Text;
 
34
 
 
35
        /// <summary>
 
36
        /// The TestResult abstract class represents
 
37
        /// the result of a test and is used to
 
38
        /// communicate results across AppDomains.
 
39
        /// </summary>
 
40
        /// 
 
41
        [Serializable]
 
42
        public abstract class TestResult
 
43
        {
 
44
                #region Fields
 
45
 
 
46
                /// <summary>
 
47
                /// True if the test executed
 
48
                /// </summary>
 
49
                private bool executed = false;
 
50
 
 
51
                /// <summary>
 
52
                /// True if the test was marked as a failure
 
53
                /// </summary>
 
54
                private bool isFailure = false; 
 
55
 
 
56
                /// <summary>
 
57
                /// The elapsed time for executing this test
 
58
                /// </summary>
 
59
                private double time = 0.0;
 
60
 
 
61
                /// <summary>
 
62
                /// The name of the test
 
63
                /// </summary>
 
64
                private string name;
 
65
 
 
66
                /// <summary>
 
67
                /// The test that this result pertains to
 
68
                /// </summary>
 
69
                private TestInfo test;
 
70
 
 
71
                /// <summary>
 
72
                /// The stacktrace at the point of failure
 
73
                /// </summary>
 
74
                private string stackTrace;
 
75
 
 
76
                /// <summary>
 
77
                /// Description of this test
 
78
                /// </summary>
 
79
                private string description;
 
80
 
 
81
                /// <summary>
 
82
                /// Message giving the reason for failure
 
83
                /// </summary>
 
84
                protected string messageString;
 
85
 
 
86
                /// <summary>
 
87
                /// Number of asserts executed by this test
 
88
                /// </summary>
 
89
                private int assertCount = 0;
 
90
 
 
91
                #endregion
 
92
 
 
93
                #region Protected Constructor
 
94
                protected TestResult(TestInfo test, string name)
 
95
                {
 
96
                        this.name = name;
 
97
                        this.test = test;
 
98
                        if(test != null)
 
99
                                this.description = test.Description;
 
100
                }
 
101
                #endregion
 
102
 
 
103
                #region Properties
 
104
 
 
105
                public bool Executed 
 
106
                {
 
107
                        get { return executed; }
 
108
                        set { executed = value; }
 
109
                }
 
110
 
 
111
                public virtual bool AllTestsExecuted
 
112
                {
 
113
                        get { return executed; }
 
114
                }
 
115
 
 
116
                public virtual string Name
 
117
                {
 
118
                        get{ return name;}
 
119
                }
 
120
 
 
121
                public TestInfo Test
 
122
                {
 
123
                        get{ return test;}
 
124
                }
 
125
 
 
126
                public virtual bool IsSuccess
 
127
                {
 
128
                        get { return !(isFailure); }
 
129
                }
 
130
                
 
131
                public virtual bool IsFailure
 
132
                {
 
133
                        get { return isFailure; }
 
134
                        set { isFailure = value; }
 
135
                }
 
136
 
 
137
                public virtual string Description
 
138
                {
 
139
                        get { return description; }
 
140
                        set { description = value; }
 
141
                }
 
142
 
 
143
                public double Time 
 
144
                {
 
145
                        get{ return time; }
 
146
                        set{ time = value; }
 
147
                }
 
148
 
 
149
                public string Message
 
150
                {
 
151
                        get { return messageString; }
 
152
                }
 
153
 
 
154
                public virtual string StackTrace
 
155
                {
 
156
                        get 
 
157
                        { 
 
158
                                return stackTrace;
 
159
                        }
 
160
                        set 
 
161
                        {
 
162
                                stackTrace = value;
 
163
                        }
 
164
                }
 
165
 
 
166
                public int AssertCount
 
167
                {
 
168
                        get { return assertCount; }
 
169
                        set { assertCount = value; }
 
170
                }
 
171
 
 
172
                #endregion
 
173
 
 
174
                #region Public Methods
 
175
 
 
176
                /// <summary>
 
177
                /// Mark the test as not run.
 
178
                /// </summary>
 
179
                /// <param name="reason">The reason the test was not run</param>
 
180
                public void NotRun(string reason)
 
181
                {
 
182
                        NotRun( reason, null );
 
183
                }
 
184
 
 
185
                /// <summary>
 
186
                /// Mark the test as not run.
 
187
                /// </summary>
 
188
                /// <param name="reason">The reason the test was not run</param>
 
189
                /// <param name="stackTrace">Stack trace giving the location of the command</param>
 
190
                public void NotRun(string reason, string stackTrace)
 
191
                {
 
192
                        this.executed = false;
 
193
                        this.messageString = reason;
 
194
                        this.stackTrace = stackTrace;
 
195
                }
 
196
 
 
197
                /// <summary>
 
198
                /// Mark the test as a failure due to an
 
199
                /// assertion having failed.
 
200
                /// </summary>
 
201
                /// <param name="message">Message to display</param>
 
202
                /// <param name="stackTrace">Stack trace giving the location of the failure</param>
 
203
                public void Failure(string message, string stackTrace )
 
204
                {
 
205
                        this.executed = true;
 
206
                        this.isFailure = true;
 
207
                        this.messageString = message;
 
208
                        this.stackTrace = stackTrace;
 
209
                }
 
210
 
 
211
                #endregion
 
212
 
 
213
                #region Exception Helpers
 
214
 
 
215
                private string BuildMessage(Exception exception)
 
216
                {
 
217
                        StringBuilder sb = new StringBuilder();
 
218
                        sb.AppendFormat( "{0} : {1}", exception.GetType().ToString(), exception.Message );
 
219
 
 
220
                        Exception inner = exception.InnerException;
 
221
                        while( inner != null )
 
222
                        {
 
223
                                sb.Append( Environment.NewLine );
 
224
                                sb.AppendFormat( "  ----> {0} : {1}", inner.GetType().ToString(), inner.Message );
 
225
                                inner = inner.InnerException;
 
226
                        }
 
227
 
 
228
                        return sb.ToString();
 
229
                }
 
230
                
 
231
                private string BuildStackTrace(Exception exception)
 
232
                {
 
233
                        if(exception.InnerException!=null)
 
234
                                return GetStackTrace(exception) + Environment.NewLine + 
 
235
                                        "--" + exception.GetType().Name + Environment.NewLine +
 
236
                                        BuildStackTrace(exception.InnerException);
 
237
                        else
 
238
                                return GetStackTrace(exception);
 
239
                }
 
240
 
 
241
                private string GetStackTrace(Exception exception)
 
242
                {
 
243
                        try
 
244
                        {
 
245
                                return exception.StackTrace;
 
246
                        }
 
247
                        catch( Exception )
 
248
                        {
 
249
                                return "No stack trace available";
 
250
                        }
 
251
                }
 
252
 
 
253
                #endregion
 
254
 
 
255
                public abstract void Accept(ResultVisitor visitor);
 
256
        }
 
257
}