~nunit-core/nunitv2/2.5

« back to all changes in this revision

Viewing changes to NUnitFitTests.html

  • Committer: charliepoole
  • Date: 2008-02-23 03:26:05 UTC
  • Revision ID: vcs-imports@canonical.com-20080223032605-y413yp2ckipdsd1s
Move non-source files like scripts to the root directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 
2
<html>
 
3
        <body>
 
4
                <h1>NUnit Acceptance Tests</h1>
 
5
                <p>
 
6
                Developers love self-referential programs! Hence, NUnit has always run all it's 
 
7
                own tests, even those that are not really unit tests.
 
8
                <p>Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's 
 
9
                        FIT framework. At this time, the tests are pretty rudimentary, but it's a start 
 
10
                        and it's a framework for doing more.
 
11
                        <h2>Running the Tests</h2>
 
12
                <p>Open a console or shell window and navigate to the NUnit bin directory, which 
 
13
                        contains this file. To run the test under Microsoft .Net, enter the command
 
14
                        <pre>    runFile NUnitFitTests.html TestResults.html .</pre>
 
15
                        To run it under Mono, enter
 
16
                        <pre>    mono runFile.exe NUnitFitTests.html TestResults.html .</pre>
 
17
                        Note the space and dot at the end of each command. The results of your test 
 
18
                        will be in TestResults.html in the same directory.
 
19
                        <h2>Platform and CLR Version</h2>
 
20
                        <table BORDER cellSpacing="0" cellPadding="5">
 
21
                                <tr>
 
22
                                        <td colspan="2">NUnit.Fixtures.PlatformInfo</td>
 
23
                                </tr>
 
24
                        </table>
 
25
                        <h2>Verify Unit Tests</h2>
 
26
                <p>
 
27
                Load and run the NUnit unit tests, verifying that the results are as expected. 
 
28
                When these tests are run on different platforms, different numbers of tests may 
 
29
                be skipped, so the values for Skipped and Run tests are informational only.
 
30
                <p>
 
31
                The number of tests in each assembly should be constant across all platforms - 
 
32
                any discrepancy usually means that one of the test source files was not 
 
33
                compiled on the platform. There should be no failures and no tests ignored.
 
34
                <p><b>Note:</b>
 
35
                At the moment, the nunit.extensions.tests assembly is failing because the 
 
36
                fixture doesn't initialize addins in the test domain.
 
37
                <p>
 
38
                        <table BORDER cellSpacing="0" cellPadding="5">
 
39
                                <tr>
 
40
                                        <td colspan="6">NUnit.Fixtures.AssemblyRunner</td>
 
41
                                </tr>
 
42
                                <tr>
 
43
                                        <td>Assembly</td>
 
44
                                        <td>Tests()</td>
 
45
                                        <td>Run()</td>
 
46
                                        <td>Skipped()</td>
 
47
                                        <td>Ignored()</td>
 
48
                                        <td>Failures()</td>
 
49
                                </tr>
 
50
                                <tr>
 
51
                                        <td>nunit.framework.tests.dll</td>
 
52
                                        <td>397</td>
 
53
                                        <td>&nbsp;</td>
 
54
                                        <td>&nbsp;</td>
 
55
                                        <td>0</td>
 
56
                                        <td>0</td>
 
57
                                </tr>
 
58
                                <tr>
 
59
                                        <td>nunit.core.tests.dll</td>
 
60
                                        <td>355</td>
 
61
                                        <td>&nbsp;</td>
 
62
                                        <td>&nbsp;</td>
 
63
                                        <td>0</td>
 
64
                                        <td>0</td>
 
65
                                </tr>
 
66
                                <tr>
 
67
                                        <td>nunit.util.tests.dll</td>
 
68
                                        <td>238</td>
 
69
                                        <td>&nbsp;</td>
 
70
                                        <td>&nbsp;</td>
 
71
                                        <td>0</td>
 
72
                                        <td>0</td>
 
73
                                </tr>
 
74
                                <tr>
 
75
                                        <td>nunit.mocks.tests.dll</td>
 
76
                                        <td>43</td>
 
77
                                        <td>&nbsp;</td>
 
78
                                        <td>&nbsp;</td>
 
79
                                        <td>0</td>
 
80
                                        <td>0</td>
 
81
                                </tr>
 
82
                                <tr>
 
83
                                        <td>nunit.extensions.tests.dll</td>
 
84
                                        <td>5</td>
 
85
                                        <td>&nbsp;</td>
 
86
                                        <td>&nbsp;</td>
 
87
                                        <td>0</td>
 
88
                                        <td>0</td>
 
89
                                </tr>
 
90
                                <tr>
 
91
                                        <td>nunit-console.tests.dll</td>
 
92
                                        <td>40</td>
 
93
                                        <td>&nbsp;</td>
 
94
                                        <td>&nbsp;</td>
 
95
                                        <td>0</td>
 
96
                                        <td>0</td>
 
97
                                </tr>
 
98
                                <tr>
 
99
                                        <td>nunit.uikit.tests.dll</td>
 
100
                                        <td>34</td>
 
101
                                        <td>&nbsp;</td>
 
102
                                        <td>&nbsp;</td>
 
103
                                        <td>0</td>
 
104
                                        <td>0</td>
 
105
                                </tr>
 
106
                                <tr>
 
107
                                        <td>nunit-gui.tests.dll</td>
 
108
                                        <td>15</td>
 
109
                                        <td>&nbsp;</td>
 
110
                                        <td>&nbsp;</td>
 
111
                                        <td>0</td>
 
112
                                        <td>0</td>
 
113
                                </tr>
 
114
                                <tr>
 
115
                                        <td>nunit.fixtures.tests.dll</td>
 
116
                                        <td>6</td>
 
117
                                        <td>&nbsp;</td>
 
118
                                        <td>&nbsp;</td>
 
119
                                        <td>0</td>
 
120
                                        <td>0</td>
 
121
                                </tr>
 
122
                        </table>
 
123
                        <h2>Code Snippet Tests</h2>
 
124
                <p>
 
125
                These tests create a test assembly from a snippet of code and then load and run 
 
126
                the tests that it contains, verifying that the structure of the loaded tests is 
 
127
                as expected and that the number of tests run, skipped, ignored or failed is 
 
128
                correct.
 
129
                <p>
 
130
                        <table BORDER cellSpacing="0" cellPadding="5">
 
131
                                <tr>
 
132
                                        <td colspan="6">NUnit.Fixtures.SnippetRunner</td>
 
133
                                </tr>
 
134
                                <tr>
 
135
                                        <td>Code</td>
 
136
                                        <td>Tree()</td>
 
137
                                        <td>Run()</td>
 
138
                                        <td>Skipped()</td>
 
139
                                        <td>Ignored()</td>
 
140
                                        <td>Failures()</td>
 
141
                                </tr>
 
142
                                <tr>
 
143
                                        <td><pre>public class TestClass
 
144
{
 
145
}</pre>
 
146
                                        </td>
 
147
                                        <td>EMPTY</td>
 
148
                                        <td>0</td>
 
149
                                        <td>0</td>
 
150
                                        <td>0</td>
 
151
                                        <td>0</td>
 
152
                                </tr>
 
153
                                <tr>
 
154
                                        <td><pre>using NUnit.Framework;
 
155
 
 
156
[TestFixture]
 
157
public class TestClass
 
158
{
 
159
}</pre>
 
160
                                        </td>
 
161
                                        <td>TestClass</td>
 
162
                                        <td>0</td>
 
163
                                        <td>0</td>
 
164
                                        <td>0</td>
 
165
                                        <td>0</td>
 
166
                                </tr>
 
167
                                <tr>
 
168
                                        <td><pre>using NUnit.Framework;
 
169
 
 
170
[TestFixture]
 
171
public class TestClass
 
172
{
 
173
    [Test]
 
174
    public void T1() { }
 
175
    [Test]
 
176
    public void T2() { }
 
177
    [Test]
 
178
    public void T3() { }
 
179
}</pre>
 
180
                                        </td>
 
181
                                        <td><pre>TestClass
 
182
&gt;T1
 
183
&gt;T2
 
184
&gt;T3</pre>
 
185
                                        </td>
 
186
                                        <td>3</td>
 
187
                                        <td>0</td>
 
188
                                        <td>0</td>
 
189
                                        <td>0</td>
 
190
                                </tr>
 
191
                                <tr>
 
192
                                        <td><pre>using NUnit.Framework;
 
193
 
 
194
[TestFixture]
 
195
public class TestClass1
 
196
{
 
197
    [Test]
 
198
    public void T1() { }
 
199
}
 
200
 
 
201
[TestFixture]
 
202
public class TestClass2
 
203
{
 
204
    [Test]
 
205
    public void T2() { }
 
206
    [Test]
 
207
    public void T3() { }
 
208
}</pre>
 
209
                                        </td>
 
210
                                        <td><pre>TestClass1
 
211
&gt;T1
 
212
TestClass2
 
213
&gt;T2
 
214
&gt;T3</pre>
 
215
                                        </td>
 
216
                                        <td>3</td>
 
217
                                        <td>0</td>
 
218
                                        <td>0</td>
 
219
                                        <td>0</td>
 
220
                                </tr>
 
221
                                <tr>
 
222
                                        <td><pre>using NUnit.Framework;
 
223
 
 
224
[TestFixture]
 
225
public class TestClass
 
226
{
 
227
    [Test]
 
228
    public void T1() { }
 
229
    [Test, Ignore]
 
230
    public void T2() { }
 
231
    [Test]
 
232
    public void T3() { }
 
233
}</pre>
 
234
                                        </td>
 
235
                                        <td><pre>TestClass
 
236
&gt;T1
 
237
&gt;T2
 
238
&gt;T3</pre>
 
239
                                        </td>
 
240
                                        <td>2</td>
 
241
                                        <td>0</td>
 
242
                                        <td>1</td>
 
243
                                        <td>0</td>
 
244
                                </tr>
 
245
                                <tr>
 
246
                                        <td><pre>using NUnit.Framework;
 
247
 
 
248
[TestFixture]
 
249
public class TestClass
 
250
{
 
251
    [Test]
 
252
    public void T1() { }
 
253
    [Test, Explicit]
 
254
    public void T2() { }
 
255
    [Test]
 
256
    public void T3() { }
 
257
}</pre>
 
258
                                        </td>
 
259
                                        <td><pre>TestClass
 
260
&gt;T1
 
261
&gt;T2
 
262
&gt;T3</pre>
 
263
                                        </td>
 
264
                                        <td>2</td>
 
265
                                        <td>1</td>
 
266
                                        <td>0</td>
 
267
                                        <td>0</td>
 
268
                                </tr>
 
269
                        </table>
 
270
                        <h2>Summary Information</h2>
 
271
                        <table BORDER cellSpacing="0" cellPadding="5">
 
272
                                <tr>
 
273
                                        <td colspan="2">fit.Summary</td>
 
274
                                </tr>
 
275
                        </table>
 
276
        </body>
 
277
</html>