← Back to branch summary

~schilling-ro/nunitv2/datasource

« back to all changes in this revision

Viewing changes to src/tests/test-assembly/TestCaseDataSourceAttributeFixture.cs

  • Committer: Robert Schilling schilling.ro@gmail.com
  • Date: 2013-05-05 18:55:02 UTC
  • Revision ID: schilling.ro@gmail.com-20130505185502-3kth0x3bguzfudmd
Mark invalid testcases as not runnable instead of filtering. Added further testcases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/test-assembly/TestCaseDataSourceAttributeFixture.cs
123
123
 
124
124
        #endregion
125
125
 
 
126
        #region Valid Conversion Tests
 
127
 
 
128
        [TestCaseDataSource(@"data\validWithString.xml", "XML")]
 
129
        public void MethodWithString(string s1, string s2, string s3)
 
130
        {
 
131
            Assert.AreEqual("String 1", s1);
 
132
            Assert.AreEqual("2", s2);
 
133
            Assert.AreEqual("-3", s3);
 
134
        }
 
135
 
 
136
        [TestCaseDataSource(@"data\validWithBool.xml", "XML")]
 
137
        public void MethodWithBool(bool trueBool, bool falseBool)
 
138
        {
 
139
            Assert.True(trueBool);
 
140
            Assert.False(falseBool);
 
141
        }
 
142
 
 
143
        [TestCaseDataSource(@"data\validWithByte.xml", "XML")]
 
144
        public void MethodWithByte(byte b1, byte b2)
 
145
        {
 
146
            Assert.AreEqual(0, b1);
 
147
            Assert.AreEqual(255, b2);
 
148
        }
 
149
 
 
150
        [TestCaseDataSource(@"data\validWithSbyte.xml", "XML")]
 
151
        public void MethodWithSbyte(sbyte b1, sbyte b2)
 
152
        {
 
153
            Assert.AreEqual(-128, b1);
 
154
            Assert.AreEqual(127, b2);
 
155
        }
 
156
 
 
157
        [TestCaseDataSource(@"data\validWithChar.xml", "XML")]
 
158
        public void MethodWithChar(char c1, char c2)
 
159
        {
 
160
            Assert.AreEqual('a', c1);
 
161
            Assert.AreEqual('b', c2);
 
162
        }
 
163
 
 
164
        [TestCaseDataSource(@"data\validWithDecimal.xml", "XML")]
 
165
        public void MethodWithDecimal(decimal d1, decimal d2)
 
166
        {
 
167
            Assert.AreEqual(-79228162514264337593543950335m, d1);
 
168
            Assert.AreEqual(79228162514264337593543950335m, d2);
 
169
        }
 
170
 
 
171
        [TestCaseDataSource(@"data\validWithFloat.xml", "XML")]
 
172
        public void MethodWithFloat(float f1, float f2, float f3, float f4)
 
173
        {
 
174
            Assert.AreEqual(0.0f, f1);
 
175
            Assert.AreEqual(-1.0f, f2);
 
176
            Assert.AreEqual(1.0f, f3);
 
177
            Assert.AreEqual(3.14f, f4);
 
178
        }
 
179
 
 
180
        [TestCaseDataSource(@"data\validWithDouble.xml", "XML")]
 
181
        public void MethodWithDouble(double d1, double d2, double d3, double d4)
 
182
        {
 
183
            Assert.AreEqual(0.0, d1);
 
184
            Assert.AreEqual(-1.0, d2);
 
185
            Assert.AreEqual(1.0, d3);
 
186
            Assert.AreEqual(3.14, d4);
 
187
        }
 
188
 
 
189
        [TestCaseDataSource(@"data\validWithInt.xml", "XML")]
 
190
        public void MethodWithInt(int i1, int i2)
 
191
        {
 
192
            Assert.AreEqual(-2147483648, i1);
 
193
            Assert.AreEqual(2147483647, i2);
 
194
        }
 
195
 
 
196
        [TestCaseDataSource(@"data\validWithUint.xml", "XML")]
 
197
        public void MethodWithUint(uint i1, uint i2)
 
198
        {
 
199
            Assert.AreEqual(0, i1);
 
200
            Assert.AreEqual(4294967295, i2);
 
201
        }
 
202
 
 
203
        [TestCaseDataSource(@"data\validWithObject.xml", "XML")]
 
204
        public void MethodWithObject(object o)
 
205
        {
 
206
            string s = o as string;
 
207
            Assert.NotNull(s);
 
208
            Assert.AreEqual("My Object", s);
 
209
        }
 
210
 
 
211
        [TestCaseDataSource(@"data\validWithLong.xml", "XML")]
 
212
        public void MethodWithLong(long l1, long l2)
 
213
        {
 
214
            Assert.AreEqual(-9223372036854775808, l1);
 
215
            Assert.AreEqual(9223372036854775807, l2);
 
216
        }
 
217
 
 
218
        [TestCaseDataSource(@"data\validWithUlong.xml", "XML")]
 
219
        public void MethodWithUlong(ulong l1, ulong l2)
 
220
        {
 
221
            Assert.AreEqual(0, l1);
 
222
            Assert.AreEqual(1844644073709551615, l2);
 
223
        }
 
224
 
 
225
        [TestCaseDataSource(@"data\validWithShort.xml", "XML")]
 
226
        public void MethodWithShort(short s1, short s2)
 
227
        {
 
228
            Assert.AreEqual(-32768, s1);
 
229
            Assert.AreEqual(32767, s2);
 
230
        }
 
231
 
 
232
        [TestCaseDataSource(@"data\validWithUshort.xml", "XML")]
 
233
        public void MethodWithUshort(ushort s1, ushort s2)
 
234
        {
 
235
            Assert.AreEqual(0, s1);
 
236
            Assert.AreEqual(65535, s2);
 
237
        }
 
238
 
 
239
        #endregion
 
240
 
 
241
        #region Array, Param tests
 
242
 
 
243
        [TestCaseDataSource(@"data\validWithObjectArray1Element.xml", "XML")]
 
244
        public void MethodWithOneObjectArrayWith1Element(object[] o)
 
245
        {
 
246
            Assert.AreEqual(1, o.Length);
 
247
            string s = o[0] as string;
 
248
            Assert.NotNull(s);
 
249
            Assert.AreEqual("My Object", s);
 
250
        }
 
251
 
 
252
        [TestCaseDataSource(@"data\validWithObjectArray3Elements.xml", "XML")]
 
253
        public void MethodWithOneObjectArrayWith3Elements(object[] o)
 
254
        {
 
255
            Assert.AreEqual(3, o.Length);
 
256
            string s = o[0] as string;
 
257
            Assert.NotNull(s);
 
258
            Assert.AreEqual("My Object 1", s);
 
259
            s = o[1] as string;
 
260
            Assert.NotNull(s);
 
261
            Assert.AreEqual("My Object 2", s);
 
262
            s = o[2] as string;
 
263
            Assert.NotNull(s);
 
264
            Assert.AreEqual("My Object 3", s);
 
265
        }
 
266
 
 
267
        [TestCaseDataSource(@"data\validParamsWith1Element.xml", "XML")]
 
268
        public void MethodWithParamsWith1Element(params int[] p)
 
269
        {
 
270
            Assert.AreEqual(1, p.Length);
 
271
            Assert.AreEqual(1, p[0]);
 
272
        }
 
273
 
 
274
        [TestCaseDataSource(@"data\validParamsWith3Elements.xml", "XML")]
 
275
        public void MethodWithParamsWith3Elements(params int[] p)
 
276
        {
 
277
            Assert.AreEqual(3, p.Length);
 
278
            Assert.AreEqual(1, p[0]);
 
279
            Assert.AreEqual(2, p[1]);
 
280
            Assert.AreEqual(3, p[2]);
 
281
        }
 
282
 
 
283
        [TestCaseDataSource(@"data\validStringWithParams.xml", "XML")]
 
284
        public void MethodStringWithParams(string s, params int[] p)
 
285
        {
 
286
            Assert.AreEqual("My String", s);
 
287
            Assert.AreEqual(3, p.Length);
 
288
            Assert.AreEqual(1, p[0]);
 
289
            Assert.AreEqual(2, p[1]);
 
290
            Assert.AreEqual(3, p[2]);
 
291
        }
 
292
 
 
293
        #endregion
 
294
 
 
295
        #region Wrong parameters tests
 
296
 
 
297
        [TestCaseDataSource(@"data\validWithTooMuchParameters.xml", "XML")]
 
298
        public void MethodWithTooMuchParameters(int x)
 
299
        {
 
300
            Assert.True(false);
 
301
        }
 
302
 
 
303
        [TestCaseDataSource(@"data\validWithTooLessParameters.xml", "XML")]
 
304
        public void MethodWithTooLessParameters(int x, int y)
 
305
        {
 
306
            Assert.True(false);
 
307
        }
 
308
 
 
309
        [TestCaseDataSource(@"data\validWithEmptyParameter.xml", "XML")]
 
310
        public void MethodWithEmptyParamter(int x, int y)
 
311
        {
 
312
            Assert.True(false);
 
313
        }
 
314
 
 
315
        [TestCaseDataSource(@"data\validWithWrongParameterType.xml", "XML")]
 
316
        public void MethodWithWrongParameterType(int x)
 
317
        {
 
318
            Assert.True(false);
 
319
        }
 
320
 
 
321
        [TestCaseDataSource(@"data\validWithWrongParameterTypeInArray.xml", "XML")]
 
322
        public void MethodWithWrongParameterTypeInArray(params int[] i)
 
323
        {
 
324
            Assert.True(false);
 
325
        }
 
326
 
 
327
        #endregion
 
328
 
 
329
        #region Result Value Tests
 
330
 
 
331
        [TestCaseDataSource(@"data\validWithValidResultValue.xml", "XML")]
 
332
        public int MethodWithValidResultValue(int x)
 
333
        {
 
334
            return 1;
 
335
        }
 
336
 
 
337
        [TestCaseDataSource(@"data\validWithInvalidResultValue.xml", "XML")]
 
338
        public int MethodWithInvalidResultValue(int x)
 
339
        {
 
340
            return 2;
 
341
        }
 
342
 
 
343
        [TestCaseDataSource(@"data\validWithWrongResultType.xml", "XML")]
 
344
        public int MethodWithWrongResultType(int x)
 
345
        {
 
346
            Assert.True(false);
 
347
            return 0;
 
348
        }
 
349
 
 
350
        #endregion
 
351
 
 
352
 
126
353
    }
127
354
}
 
 
b'\\ No newline at end of file'