?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[System.Reflection] Make GetFieldOffset method virtual to fix issue with custom Field...
[mono-project.git] / mcs / class / corlib / Test / System.Reflection / FieldInfoTest.cs
blobd21482dd20de15c4f82a6e1de4ba57ae0f156a91
1 //
2 // FieldInfoTest - NUnit Test Cases for the FieldInfo class
3 //
4 // Authors:
5 // Zoltan Varga (vargaz@freemail.hu)
6 // Gert Driesen (drieseng@users.sourceforge.net)
7 //
8 // (c) 2003 Ximian, Inc. (http://www.ximian.com)
9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
10 //
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
18 //
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
21 //
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30
31 using System;
32 using System.Globalization;
33 using System.Threading;
34 using System.Reflection;
35 #if !MONOTOUCH && !FULL_AOT_RUNTIME
36 using System.Reflection.Emit;
37 #endif
38 using System.Runtime.InteropServices;
39
40 using NUnit.Framework;
41
42 namespace MonoTests.System.Reflection
43 {
44 [StructLayout(LayoutKind.Explicit, Pack = 4, Size = 64)]
45 public class Class1
46 {
47 [FieldOffset (32)]
48 public int i;
49 }
50
51 [StructLayout(LayoutKind.Sequential)]
52 public class Class2
53 {
54 [MarshalAsAttribute(UnmanagedType.Bool)]
55 public int f0;
56
57 [MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.LPStr)]
58 public string[] f1;
59
60 [MarshalAs(UnmanagedType.ByValTStr, SizeConst=100)]
61 public string f2;
62 #if FEATURE_COMINTEROP
63 [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof (Marshal1), MarshalCookie="5")]
64 public int f3;
65
66 [MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof (Marshal1), MarshalCookie = "5")]
67 public object f4;
68 #endif
69 [Obsolete]
70 public int f5;
71 }
72
73 public class Class3 : Class2
74 {
75 }
76
77 // Disable this warning, as the purpose of this struct is to poke at the internal via reflection
78 #pragma warning disable 649
79 class FieldInvokeMatrix
80 {
81 public Byte field_Byte;
82 public SByte field_SByte;
83 public Boolean field_Boolean;
84 public Char field_Char;
85 public Int16 field_Int16;
86 public UInt16 field_UInt16;
87 public Int32 field_Int32;
88 public UInt32 field_UInt32;
89 public Int64 field_Int64;
90 public UInt64 field_UInt64;
91 public Single field_Single;
92 public Double field_Double;
93 public IntPtr field_IntPtr;
94 public UIntPtr field_UIntPtr;
95 public Decimal field_Decimal;
96 public DateTime field_DateTime;
97 public String field_String;
98
99 public ByteEnum field_ByteEnum;
100 public SByteEnum field_SByteEnum;
101 public Int16Enum field_Int16Enum;
102 public UInt16Enum field_UInt16Enum;
103 public Int32Enum field_Int32Enum;
104 public UInt32Enum field_UInt32Enum;
105 public Int64Enum field_Int64Enum;
106 public UInt64Enum field_UInt64Enum;
107 }
108 #pragma warning restore 649
109
110 public enum ByteEnum : byte
111 {
112 MaxValue = Byte.MaxValue
113 }
114
115 public enum SByteEnum : sbyte
116 {
117 MaxValue = SByte.MaxValue
118 }
119
120 public enum Int16Enum : short
121 {
122 MaxValue = Int16.MaxValue
123 }
124
125 public enum UInt16Enum : ushort
126 {
127 MaxValue = UInt16.MaxValue
128 }
129
130 public enum Int32Enum : int
131 {
132 MaxValue = Int32.MaxValue
133 }
134
135 public enum UInt32Enum: uint
136 {
137 MaxValue= UInt32.MaxValue
138 }
139
140 public enum Int64Enum : long
141 {
142 MaxValue = Int64.MaxValue
143 }
144
145 public enum UInt64Enum: ulong
146 {
147 MaxValue = UInt64.MaxValue
148 }
149
150 [TestFixture]
151 public unsafe class FieldInfoTest
152 {
153 [NonSerialized]
154 public int i;
155
156 [Test]
157 public void IsDefined_AttributeType_Null ()
158 {
159 Type type = typeof (FieldInfoTest);
160 FieldInfo field = type.GetField ("i");
161
162 try {
163 field.IsDefined ((Type) null, false);
164 Assert.Fail ("#1");
165 } catch (ArgumentNullException ex) {
166 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
167 Assert.IsNull (ex.InnerException, "#3");
168 Assert.IsNotNull (ex.Message, "#4");
169 Assert.IsNotNull (ex.ParamName, "#5");
170 Assert.AreEqual ("attributeType", ex.ParamName, "#6");
171 }
172 }
173
174 [Test]
175 public void FieldInfoModule ()
176 {
177 Type type = typeof (FieldInfoTest);
178 FieldInfo field = type.GetField ("i");
179
180 Assert.AreEqual (type.Module, field.Module);
181 }
182
183 [Test]
184 public void GetCustomAttributes ()
185 {
186 object [] attrs;
187 FieldInfo fi;
188
189 fi = typeof (Class2).GetField ("f5");
190
191 attrs = fi.GetCustomAttributes (false);
192 Assert.AreEqual (1, attrs.Length, "#B1");
193 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B2");
194 attrs = fi.GetCustomAttributes (true);
195 Assert.AreEqual (1, attrs.Length, "#B3");
196 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B4");
197 attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), false);
198 Assert.AreEqual (0, attrs.Length, "#B5");
199 attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), true);
200 Assert.AreEqual (0, attrs.Length, "#B6");
201 attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), false);
202 Assert.AreEqual (1, attrs.Length, "#B7");
203 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B8");
204 attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), true);
205 Assert.AreEqual (1, attrs.Length, "#B9");
206 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B10");
207
208 fi = typeof (Class3).GetField ("f5");
209
210 attrs = fi.GetCustomAttributes (false);
211 Assert.AreEqual (1, attrs.Length, "#D1");
212 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D2");
213 attrs = fi.GetCustomAttributes (true);
214 Assert.AreEqual (1, attrs.Length, "#D3");
215 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D4");
216 attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), false);
217 Assert.AreEqual (0, attrs.Length, "#D5");
218 attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), true);
219 Assert.AreEqual (0, attrs.Length, "#D6");
220 attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), false);
221 Assert.AreEqual (1, attrs.Length, "#D7");
222 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D8");
223 attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), true);
224 Assert.AreEqual (1, attrs.Length, "#D9");
225 Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D10");
226 }
227
228 [Test]
229 public void MetadataToken ()
230 {
231 Type type = typeof (FieldInfoTest);
232 FieldInfo field = type.GetField ("i");
233 Assert.IsTrue ((int)field.MetadataToken > 0);
234 }
235
236 [Test] // GetFieldFromHandle (RuntimeFieldHandle)
237 public void GetFieldFromHandle1_Handle_Zero ()
238 {
239 RuntimeFieldHandle fh = new RuntimeFieldHandle ();
240
241 try {
242 FieldInfo.GetFieldFromHandle (fh);
243 Assert.Fail ("#1");
244 } catch (ArgumentException ex) {
245 // Handle is not initialized
246 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
247 Assert.IsNull (ex.InnerException, "#3");
248 Assert.IsNotNull (ex.Message, "#4");
249 Assert.IsNull (ex.ParamName, "#5");
250 }
251 }
252
253 [Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
254 public void GetFieldFromHandle2_DeclaringType_Zero ()
255 {
256 RuntimeTypeHandle th = new RuntimeTypeHandle ();
257 FieldInfo fi1 = typeof (Class2).GetField ("f5");
258 RuntimeFieldHandle fh = fi1.FieldHandle;
259
260 FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
261 Assert.IsNotNull (fi2, "#1");
262 Assert.AreSame (fi1.DeclaringType, fi2.DeclaringType, "#2");
263 Assert.AreEqual (fi1.FieldType, fi2.FieldType, "#3");
264 Assert.AreEqual (fi1.Name, fi2.Name, "#4");
265 }
266
267 [Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
268 public void GetFieldFromHandle2_Handle_Generic ()
269 {
270 FieldInfoTest<string> instance = new FieldInfoTest<string> ();
271 Type t = instance.GetType ();
272
273 FieldInfo fi1 = t.GetField ("TestField");
274 RuntimeFieldHandle fh = fi1.FieldHandle;
275 RuntimeTypeHandle th = t.TypeHandle;
276
277 FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
278 Assert.IsNotNull (fi2, "#1");
279 Assert.AreSame (t, fi2.DeclaringType, "#2");
280 Assert.AreEqual (typeof (string), fi2.FieldType, "#3");
281 Assert.AreEqual ("TestField", fi2.Name, "#4");
282 }
283
284 [Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
285 [Category ("NotWorking")]
286 [Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=343449
287 public void GetFieldFromHandle2_Handle_GenericDefinition ()
288 {
289 Type t1 = typeof (FieldInfoTest<>);
290 FieldInfo fi1 = t1.GetField ("TestField");
291 RuntimeFieldHandle fh = fi1.FieldHandle;
292
293 FieldInfoTest<string> instance = new FieldInfoTest<string> ();
294 Type t2 = instance.GetType ();
295 RuntimeTypeHandle th = t2.TypeHandle;
296
297 FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
298 Assert.IsNotNull (fi2, "#1");
299 Assert.AreSame (t2, fi2.DeclaringType, "#2");
300 Assert.AreEqual (typeof (string), fi2.FieldType, "#3");
301 Assert.AreEqual ("TestField", fi2.Name, "#4");
302 }
303
304 [Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
305 public void GetFieldFromHandle2_Handle_Zero ()
306 {
307 object instance = new Class2 ();
308 RuntimeTypeHandle th = Type.GetTypeHandle (instance);
309 RuntimeFieldHandle fh = new RuntimeFieldHandle ();
310
311 try {
312 FieldInfo.GetFieldFromHandle (fh, th);
313 Assert.Fail ("#1");
314 } catch (ArgumentException ex) {
315 // Handle is not initialized
316 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
317 Assert.IsNull (ex.InnerException, "#3");
318 Assert.IsNotNull (ex.Message, "#4");
319 Assert.IsNull (ex.ParamName, "#5");
320 }
321 }
322
323 [Test]
324 [ExpectedException (typeof (ArgumentException))]
325 public void GetFieldFromHandle2_Incompatible ()
326 {
327 RuntimeFieldHandle fh = typeof (FieldInfoTest<int>).GetField ("TestField").FieldHandle;
328
329 FieldInfoTest<string> instance = new FieldInfoTest<string> ();
330 Type t2 = instance.GetType ();
331 RuntimeTypeHandle th = t2.TypeHandle;
332
333 FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
334 }
335
336 [Test]
337 public void PseudoCustomAttributes ()
338 {
339 object [] attrs;
340 Type t = typeof (FieldInfoTest);
341
342 Assert.AreEqual (1, t.GetField ("i").GetCustomAttributes (typeof (NonSerializedAttribute), true).Length);
343
344 attrs = typeof (Class1).GetField ("i").GetCustomAttributes (true);
345 Assert.AreEqual (1, attrs.Length, "#B1");
346 FieldOffsetAttribute field_attr = (FieldOffsetAttribute) attrs [0];
347 Assert.AreEqual (32, field_attr.Value, "#B2");
348
349 MarshalAsAttribute attr;
350
351 attrs = typeof (Class2).GetField ("f0").GetCustomAttributes (true);
352 Assert.AreEqual (1, attrs.Length, "#C1");
353 attr = (MarshalAsAttribute) attrs [0];
354 Assert.AreEqual (UnmanagedType.Bool, attr.Value, "#C2");
355
356 attrs = typeof (Class2).GetField ("f1").GetCustomAttributes (true);
357 Assert.AreEqual (1, attrs.Length, "#D1");
358 attr = (MarshalAsAttribute) attrs [0];
359 Assert.AreEqual (UnmanagedType.LPArray, attr.Value, "#D2");
360 Assert.AreEqual (UnmanagedType.LPStr, attr.ArraySubType, "#D3");
361
362 attrs = typeof (Class2).GetField ("f2").GetCustomAttributes (true);
363 Assert.AreEqual (1, attrs.Length, "#E1");
364 attr = (MarshalAsAttribute) attrs [0];
365 Assert.AreEqual (UnmanagedType.ByValTStr, attr.Value, "#E2");
366 Assert.AreEqual (100, attr.SizeConst, "#E3");
367
368 #if FEATURE_COMINTEROP
369 attrs = typeof (Class2).GetField ("f3").GetCustomAttributes (true);
370 Assert.AreEqual (1, attrs.Length, "#F1");
371 attr = (MarshalAsAttribute) attrs [0];
372 Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#F2");
373
374 Assert.AreEqual ("5", attr.MarshalCookie, "#F3");
375 Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#F4");
376
377 attrs = typeof (Class3).GetField ("f3").GetCustomAttributes (false);
378 Assert.AreEqual (1, attrs.Length, "#G1");
379 attr = (MarshalAsAttribute) attrs [0];
380 Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#G2");
381 Assert.AreEqual ("5", attr.MarshalCookie, "#G3");
382 Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#G4");
383
384 attrs = typeof (Class3).GetField ("f3").GetCustomAttributes (true);
385 Assert.AreEqual (1, attrs.Length, "#H1");
386 attr = (MarshalAsAttribute) attrs [0];
387 Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#H2");
388 Assert.AreEqual ("5", attr.MarshalCookie, "#H3");
389 Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#H4");
390
391 // bug #82465
392 attrs = typeof (Class2).GetField ("f3").GetCustomAttributes (true);
393 Assert.AreEqual (1, attrs.Length, "#I1");
394 attr = (MarshalAsAttribute) attrs [0];
395 Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#I2");
396 Assert.AreEqual ("5", attr.MarshalCookie, "#I3");
397 Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#I4");
398 #endif
399 }
400
401 // Disable "field not used warning", this is intended.
402 #pragma warning disable 649
403 class Foo {
404 public static int static_field;
405 public int field;
406 }
407 #pragma warning restore 649
408
409 [ExpectedException (typeof (ArgumentException))]
410 public void GetValueWrongObject ()
411 {
412 Foo f = new Foo ();
413
414 typeof (Foo).GetField ("field").GetValue (typeof (int));
415 }
416
417 public void GetValueWrongObjectStatic ()
418 {
419 Foo f = new Foo ();
420
421 // This is allowed in MS.NET
422 typeof (Foo).GetField ("static_field").GetValue (typeof (int));
423 }
424
425 [Test]
426 [ExpectedException (typeof (InvalidOperationException))]
427 public void GetValueOnRefOnlyAssembly ()
428 {
429 Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
430 Type t = assembly.GetType (typeof (RefOnlyFieldClass).FullName);
431 FieldInfo f = t.GetField ("RefOnlyField", BindingFlags.Static | BindingFlags.NonPublic);
432 f.GetValue (null);
433 }
434
435 [Test]
436 [ExpectedException (typeof (InvalidOperationException))]
437 public void SetValueOnRefOnlyAssembly ()
438 {
439 Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
440 Type t = assembly.GetType (typeof (RefOnlyFieldClass).FullName);
441 FieldInfo f = t.GetField ("RefOnlyField", BindingFlags.Static | BindingFlags.NonPublic);
442 f.SetValue (null, 8);
443 }
444
445 const int literal = 42;
446
447 [Test]
448 [ExpectedException (typeof (FieldAccessException))]
449 public void SetValueOnLiteralField ()
450 {
451 FieldInfo f = typeof (FieldInfoTest).GetField ("literal", BindingFlags.Static | BindingFlags.NonPublic);
452 f.SetValue (null, 0);
453 }
454
455 public int? nullable_field;
456
457 public static int? static_nullable_field;
458
459 [Test]
460 public void NullableTests ()
461 {
462 FieldInfoTest t = new FieldInfoTest ();
463
464 FieldInfo fi = typeof (FieldInfoTest).GetField ("nullable_field");
465
466 fi.SetValue (t, 101);
467 Assert.AreEqual (101, fi.GetValue (t));
468 fi.SetValue (t, null);
469 Assert.AreEqual (null, fi.GetValue (t));
470
471 FieldInfo fi2 = typeof (FieldInfoTest).GetField ("static_nullable_field");
472
473 fi2.SetValue (t, 101);
474 Assert.AreEqual (101, fi2.GetValue (t));
475 fi2.SetValue (t, null);
476 Assert.AreEqual (null, fi2.GetValue (t));
477 }
478
479 [Test]
480 public void NonPublicTests ()
481 {
482 Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
483
484 Type t = assembly.GetType (typeof (NonPublicFieldClass).FullName);
485
486 // try to get non-public field
487 FieldInfo fi = t.GetField ("protectedField");
488 Assert.IsNull (fi);
489 // get it for real
490 fi = t.GetField ("protectedField", BindingFlags.NonPublic | BindingFlags.Instance);
491 Assert.IsNotNull (fi);
492 }
493
494 [Test]
495 public void GetRawDefaultValue ()
496 {
497 Assert.AreEqual (5, typeof (FieldInfoTest).GetField ("int_field").GetRawConstantValue ());
498 Assert.AreEqual (Int64.MaxValue, typeof (FieldInfoTest).GetField ("long_field").GetRawConstantValue ());
499 Assert.AreEqual (2, typeof (FieldInfoTest).GetField ("int_enum_field").GetRawConstantValue ());
500 Assert.AreEqual (typeof (int), typeof (FieldInfoTest).GetField ("int_enum_field").GetRawConstantValue ().GetType ());
501 Assert.AreEqual (2, typeof (FieldInfoTest).GetField ("long_enum_field").GetRawConstantValue ());
502 Assert.AreEqual (typeof (long), typeof (FieldInfoTest).GetField ("long_enum_field").GetRawConstantValue ().GetType ());
503 Assert.AreEqual ("Hello", typeof (FieldInfoTest).GetField ("string_field").GetRawConstantValue ());
504 Assert.AreEqual (null, typeof (FieldInfoTest).GetField ("object_field").GetRawConstantValue ());
505 }
506
507 [Test]
508 [ExpectedException (typeof (InvalidOperationException))]
509 public void GetRawDefaultValueNoDefault ()
510 {
511 typeof (FieldInfoTest).GetField ("non_const_field").GetRawConstantValue ();
512 }
513
514 [Test]
515 [ExpectedException (typeof (InvalidOperationException))]
516 public void GetValueOpenGeneric ()
517 {
518 typeof(Foo<>).GetField ("field").GetValue (null);
519 }
520
521 [Test]
522 [ExpectedException (typeof (InvalidOperationException))]
523 public void SetValueOpenGeneric ()
524 {
525 typeof(Foo<>).GetField ("field").SetValue (null, 0);
526 }
527
528 [Test]
529 public void GetValueOnConstantOfOpenGeneric ()
530 {
531 Assert.AreEqual (10, typeof(Foo<>).GetField ("constant").GetValue (null), "#1");
532 Assert.AreEqual ("waa", typeof(Foo<>).GetField ("sconstant").GetValue (null), "#2");
533 Assert.AreEqual (IntEnum.Third, typeof(Foo<>).GetField ("econstant").GetValue (null), "#3");
534 }
535
536 public static unsafe void* ip;
537
538 [Test]
539 public unsafe void GetSetValuePointers ()
540 {
541 Pointer p0 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
542 int *p0i = (int*)Pointer.Unbox (p0);
543 Assert.AreEqual (IntPtr.Zero, new IntPtr (p0i));
544
545 int i = 5;
546 void *p = &i;
547 typeof (FieldInfoTest).GetField ("ip").SetValue (null, (IntPtr)p);
548 Pointer p2 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
549
550 int *pi = (int*)Pointer.Unbox (p2);
551 Assert.AreEqual (5, *pi);
552
553 typeof (FieldInfoTest).GetField ("ip").SetValue (null, (UIntPtr)p);
554 p2 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
555
556 pi = (int*)Pointer.Unbox (p2);
557 Assert.AreEqual (5, *pi);
558 }
559
560 [Test]
561 public void SetValuePrimitiveConversions ()
562 {
563 FieldInfo field;
564 var instance = new FieldInvokeMatrix ();
565 var fh = typeof (FieldInvokeMatrix);
566
567 field = fh.GetField ("field_Byte");
568 field.SetValue (instance, Byte.MaxValue);
569 Assert.AreEqual (Byte.MaxValue, instance.field_Byte);
570 Throws (field, instance, SByte.MaxValue);
571 Throws (field, instance, true);
572 Throws (field, instance, Char.MaxValue);
573 Throws (field, instance, Int16.MaxValue);
574 Throws (field, instance, UInt16.MaxValue);
575 Throws (field, instance, Int32.MaxValue);
576 Throws (field, instance, UInt32.MaxValue);
577 Throws (field, instance, Int64.MaxValue);
578 Throws (field, instance, UInt64.MaxValue);
579 Throws (field, instance, Single.MaxValue);
580 Throws (field, instance, Double.MaxValue);
581 Throws (field, instance, IntPtr.Zero);
582 Throws (field, instance, UIntPtr.Zero);
583 Throws (field, instance, Decimal.MaxValue);
584 Throws (field, instance, DateTime.MaxValue);
585 field.SetValue (instance, ByteEnum.MaxValue);
586 Assert.AreEqual (Byte.MaxValue, instance.field_Byte);
587 Throws (field, instance, SByteEnum.MaxValue);
588 Throws (field, instance, Int16Enum.MaxValue);
589 Throws (field, instance, UInt16Enum.MaxValue);
590 Throws (field, instance, Int32Enum.MaxValue);
591 Throws (field, instance, UInt32Enum.MaxValue);
592 Throws (field, instance, Int64Enum.MaxValue);
593 Throws (field, instance, UInt64Enum.MaxValue);
594 field = fh.GetField ("field_SByte");
595 Throws (field, instance, Byte.MaxValue);
596 field.SetValue (instance, SByte.MaxValue);
597 Assert.AreEqual (SByte.MaxValue, instance.field_SByte);
598 Throws (field, instance, true);
599 Throws (field, instance, Char.MaxValue);
600 Throws (field, instance, Int16.MaxValue);
601 Throws (field, instance, UInt16.MaxValue);
602 Throws (field, instance, Int32.MaxValue);
603 Throws (field, instance, UInt32.MaxValue);
604 Throws (field, instance, Int64.MaxValue);
605 Throws (field, instance, UInt64.MaxValue);
606 Throws (field, instance, Single.MaxValue);
607 Throws (field, instance, Double.MaxValue);
608 Throws (field, instance, IntPtr.Zero);
609 Throws (field, instance, UIntPtr.Zero);
610 Throws (field, instance, Decimal.MaxValue);
611 Throws (field, instance, DateTime.MaxValue);
612 Throws (field, instance, ByteEnum.MaxValue);
613 field.SetValue (instance, SByteEnum.MaxValue);
614 Assert.AreEqual (SByte.MaxValue, instance.field_SByte);
615 Throws (field, instance, Int16Enum.MaxValue);
616 Throws (field, instance, UInt16Enum.MaxValue);
617 Throws (field, instance, Int32Enum.MaxValue);
618 Throws (field, instance, UInt32Enum.MaxValue);
619 Throws (field, instance, Int64Enum.MaxValue);
620 Throws (field, instance, UInt64Enum.MaxValue);
621 field = fh.GetField ("field_Boolean");
622 Throws (field, instance, Byte.MaxValue);
623 Throws (field, instance, SByte.MaxValue);
624 field.SetValue (instance, true);
625 Assert.AreEqual (true, instance.field_Boolean);
626 Throws (field, instance, Char.MaxValue);
627 Throws (field, instance, Int16.MaxValue);
628 Throws (field, instance, UInt16.MaxValue);
629 Throws (field, instance, Int32.MaxValue);
630 Throws (field, instance, UInt32.MaxValue);
631 Throws (field, instance, Int64.MaxValue);
632 Throws (field, instance, UInt64.MaxValue);
633 Throws (field, instance, Single.MaxValue);
634 Throws (field, instance, Double.MaxValue);
635 Throws (field, instance, IntPtr.Zero);
636 Throws (field, instance, UIntPtr.Zero);
637 Throws (field, instance, Decimal.MaxValue);
638 Throws (field, instance, DateTime.MaxValue);
639 Throws (field, instance, ByteEnum.MaxValue);
640 Throws (field, instance, SByteEnum.MaxValue);
641 Throws (field, instance, Int16Enum.MaxValue);
642 Throws (field, instance, UInt16Enum.MaxValue);
643 Throws (field, instance, Int32Enum.MaxValue);
644 Throws (field, instance, UInt32Enum.MaxValue);
645 Throws (field, instance, Int64Enum.MaxValue);
646 Throws (field, instance, UInt64Enum.MaxValue);
647 field = fh.GetField ("field_Char");
648 field.SetValue (instance, Byte.MaxValue);
649 Assert.AreEqual (Byte.MaxValue, instance.field_Char);
650 Throws (field, instance, SByte.MaxValue);
651 Throws (field, instance, true);
652 field.SetValue (instance, Char.MaxValue);
653 Assert.AreEqual (Char.MaxValue, instance.field_Char);
654 Throws (field, instance, Int16.MaxValue);
655 field.SetValue (instance, UInt16.MaxValue);
656 Assert.AreEqual (UInt16.MaxValue, instance.field_Char);
657 Throws (field, instance, Int32.MaxValue);
658 Throws (field, instance, UInt32.MaxValue);
659 Throws (field, instance, Int64.MaxValue);
660 Throws (field, instance, UInt64.MaxValue);
661 Throws (field, instance, Single.MaxValue);
662 Throws (field, instance, Double.MaxValue);
663 Throws (field, instance, IntPtr.Zero);
664 Throws (field, instance, UIntPtr.Zero);
665 Throws (field, instance, Decimal.MaxValue);
666 Throws (field, instance, DateTime.MaxValue);
667 field.SetValue (instance, ByteEnum.MaxValue);
668 Assert.AreEqual (Byte.MaxValue, instance.field_Char);
669 Throws (field, instance, SByteEnum.MaxValue);
670 Throws (field, instance, Int16Enum.MaxValue);
671 field.SetValue (instance, UInt16Enum.MaxValue);
672 Assert.AreEqual (UInt16.MaxValue, instance.field_Char);
673 Throws (field, instance, Int32Enum.MaxValue);
674 Throws (field, instance, UInt32Enum.MaxValue);
675 Throws (field, instance, Int64Enum.MaxValue);
676 Throws (field, instance, UInt64Enum.MaxValue);
677 field = fh.GetField ("field_Int16");
678 field.SetValue (instance, Byte.MaxValue);
679 Assert.AreEqual (Byte.MaxValue, instance.field_Int16);
680 field.SetValue (instance, SByte.MaxValue);
681 Assert.AreEqual (SByte.MaxValue, instance.field_Int16);
682 Throws (field, instance, true);
683 Throws (field, instance, Char.MaxValue);
684 field.SetValue (instance, Int16.MaxValue);
685 Assert.AreEqual (Int16.MaxValue, instance.field_Int16);
686 Throws (field, instance, UInt16.MaxValue);
687 Throws (field, instance, Int32.MaxValue);
688 Throws (field, instance, UInt32.MaxValue);
689 Throws (field, instance, Int64.MaxValue);
690 Throws (field, instance, UInt64.MaxValue);
691 Throws (field, instance, Single.MaxValue);
692 Throws (field, instance, Double.MaxValue);
693 Throws (field, instance, IntPtr.Zero);
694 Throws (field, instance, UIntPtr.Zero);
695 Throws (field, instance, Decimal.MaxValue);
696 Throws (field, instance, DateTime.MaxValue);
697 field.SetValue (instance, ByteEnum.MaxValue);
698 Assert.AreEqual (Byte.MaxValue, instance.field_Int16);
699 field.SetValue (instance, SByteEnum.MaxValue);
700 Assert.AreEqual (SByte.MaxValue, instance.field_Int16);
701 field.SetValue (instance, Int16Enum.MaxValue);
702 Assert.AreEqual (Int16.MaxValue, instance.field_Int16);
703 Throws (field, instance, UInt16Enum.MaxValue);
704 Throws (field, instance, Int32Enum.MaxValue);
705 Throws (field, instance, UInt32Enum.MaxValue);
706 Throws (field, instance, Int64Enum.MaxValue);
707 Throws (field, instance, UInt64Enum.MaxValue);
708 field = fh.GetField ("field_UInt16");
709 field.SetValue (instance, Byte.MaxValue);
710 Assert.AreEqual (Byte.MaxValue, instance.field_UInt16);
711 Throws (field, instance, SByte.MaxValue);
712 Throws (field, instance, true);
713 field.SetValue (instance, Char.MaxValue);
714 Assert.AreEqual (Char.MaxValue, instance.field_UInt16);
715 Throws (field, instance, Int16.MaxValue);
716 field.SetValue (instance, UInt16.MaxValue);
717 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt16);
718 Throws (field, instance, Int32.MaxValue);
719 Throws (field, instance, UInt32.MaxValue);
720 Throws (field, instance, Int64.MaxValue);
721 Throws (field, instance, UInt64.MaxValue);
722 Throws (field, instance, Single.MaxValue);
723 Throws (field, instance, Double.MaxValue);
724 Throws (field, instance, IntPtr.Zero);
725 Throws (field, instance, UIntPtr.Zero);
726 Throws (field, instance, Decimal.MaxValue);
727 Throws (field, instance, DateTime.MaxValue);
728 field.SetValue (instance, ByteEnum.MaxValue);
729 Assert.AreEqual (Byte.MaxValue, instance.field_UInt16);
730 Throws (field, instance, SByteEnum.MaxValue);
731 Throws (field, instance, Int16Enum.MaxValue);
732 field.SetValue (instance, UInt16Enum.MaxValue);
733 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt16);
734 Throws (field, instance, Int32Enum.MaxValue);
735 Throws (field, instance, UInt32Enum.MaxValue);
736 Throws (field, instance, Int64Enum.MaxValue);
737 Throws (field, instance, UInt64Enum.MaxValue);
738 field = fh.GetField ("field_Int32");
739 field.SetValue (instance, Byte.MaxValue);
740 Assert.AreEqual (Byte.MaxValue, instance.field_Int32);
741 field.SetValue (instance, SByte.MaxValue);
742 Assert.AreEqual (SByte.MaxValue, instance.field_Int32);
743 Throws (field, instance, true);
744 field.SetValue (instance, Char.MaxValue);
745 Assert.AreEqual (Char.MaxValue, instance.field_Int32);
746 field.SetValue (instance, Int16.MaxValue);
747 Assert.AreEqual (Int16.MaxValue, instance.field_Int32);
748 field.SetValue (instance, UInt16.MaxValue);
749 Assert.AreEqual (UInt16.MaxValue, instance.field_Int32);
750 field.SetValue (instance, Int32.MaxValue);
751 Assert.AreEqual (Int32.MaxValue, instance.field_Int32);
752 Throws (field, instance, UInt32.MaxValue);
753 Throws (field, instance, Int64.MaxValue);
754 Throws (field, instance, UInt64.MaxValue);
755 Throws (field, instance, Single.MaxValue);
756 Throws (field, instance, Double.MaxValue);
757 Throws (field, instance, IntPtr.Zero);
758 Throws (field, instance, UIntPtr.Zero);
759 Throws (field, instance, Decimal.MaxValue);
760 Throws (field, instance, DateTime.MaxValue);
761 field.SetValue (instance, ByteEnum.MaxValue);
762 Assert.AreEqual (Byte.MaxValue, instance.field_Int32);
763 field.SetValue (instance, SByteEnum.MaxValue);
764 Assert.AreEqual (SByte.MaxValue, instance.field_Int32);
765 field.SetValue (instance, Int16Enum.MaxValue);
766 Assert.AreEqual (Int16.MaxValue, instance.field_Int32);
767 field.SetValue (instance, UInt16Enum.MaxValue);
768 Assert.AreEqual (UInt16.MaxValue, instance.field_Int32);
769 field.SetValue (instance, Int32Enum.MaxValue);
770 Assert.AreEqual (Int32.MaxValue, instance.field_Int32);
771 Throws (field, instance, UInt32Enum.MaxValue);
772 Throws (field, instance, Int64Enum.MaxValue);
773 Throws (field, instance, UInt64Enum.MaxValue);
774 field = fh.GetField ("field_UInt32");
775 field.SetValue (instance, Byte.MaxValue);
776 Assert.AreEqual (Byte.MaxValue, instance.field_UInt32);
777 Throws (field, instance, SByte.MaxValue);
778 Throws (field, instance, true);
779 field.SetValue (instance, Char.MaxValue);
780 Assert.AreEqual (Char.MaxValue, instance.field_UInt32);
781 Throws (field, instance, Int16.MaxValue);
782 field.SetValue (instance, UInt16.MaxValue);
783 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt32);
784 Throws (field, instance, Int32.MaxValue);
785 field.SetValue (instance, UInt32.MaxValue);
786 Assert.AreEqual (UInt32.MaxValue, instance.field_UInt32);
787 Throws (field, instance, Int64.MaxValue);
788 Throws (field, instance, UInt64.MaxValue);
789 Throws (field, instance, Single.MaxValue);
790 Throws (field, instance, Double.MaxValue);
791 Throws (field, instance, IntPtr.Zero);
792 Throws (field, instance, UIntPtr.Zero);
793 Throws (field, instance, Decimal.MaxValue);
794 Throws (field, instance, DateTime.MaxValue);
795 field.SetValue (instance, ByteEnum.MaxValue);
796 Assert.AreEqual (Byte.MaxValue, instance.field_UInt32);
797 Throws (field, instance, SByteEnum.MaxValue);
798 Throws (field, instance, Int16Enum.MaxValue);
799 field.SetValue (instance, UInt16Enum.MaxValue);
800 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt32);
801 Throws (field, instance, Int32Enum.MaxValue);
802 field.SetValue (instance, UInt32Enum.MaxValue);
803 Assert.AreEqual (UInt32.MaxValue, instance.field_UInt32);
804 Throws (field, instance, Int64Enum.MaxValue);
805 Throws (field, instance, UInt64Enum.MaxValue);
806 field = fh.GetField ("field_Int64");
807 field.SetValue (instance, Byte.MaxValue);
808 Assert.AreEqual (Byte.MaxValue, instance.field_Int64);
809 field.SetValue (instance, SByte.MaxValue);
810 Assert.AreEqual (SByte.MaxValue, instance.field_Int64);
811 Throws (field, instance, true);
812 field.SetValue (instance, Char.MaxValue);
813 Assert.AreEqual (Char.MaxValue, instance.field_Int64);
814 field.SetValue (instance, Int16.MaxValue);
815 Assert.AreEqual (Int16.MaxValue, instance.field_Int64);
816 field.SetValue (instance, UInt16.MaxValue);
817 Assert.AreEqual (UInt16.MaxValue, instance.field_Int64);
818 field.SetValue (instance, Int32.MaxValue);
819 Assert.AreEqual (Int32.MaxValue, instance.field_Int64);
820 field.SetValue (instance, UInt32.MaxValue);
821 Assert.AreEqual (UInt32.MaxValue, instance.field_Int64);
822 field.SetValue (instance, Int64.MaxValue);
823 Assert.AreEqual (Int64.MaxValue, instance.field_Int64);
824 Throws (field, instance, UInt64.MaxValue);
825 Throws (field, instance, Single.MaxValue);
826 Throws (field, instance, Double.MaxValue);
827 Throws (field, instance, IntPtr.Zero);
828 Throws (field, instance, UIntPtr.Zero);
829 Throws (field, instance, Decimal.MaxValue);
830 Throws (field, instance, DateTime.MaxValue);
831 field.SetValue (instance, ByteEnum.MaxValue);
832 Assert.AreEqual (Byte.MaxValue, instance.field_Int64);
833 field.SetValue (instance, SByteEnum.MaxValue);
834 Assert.AreEqual (SByte.MaxValue, instance.field_Int64);
835 field.SetValue (instance, Int16Enum.MaxValue);
836 Assert.AreEqual (Int16.MaxValue, instance.field_Int64);
837 field.SetValue (instance, UInt16Enum.MaxValue);
838 Assert.AreEqual (UInt16.MaxValue, instance.field_Int64);
839 field.SetValue (instance, Int32Enum.MaxValue);
840 Assert.AreEqual (Int32.MaxValue, instance.field_Int64);
841 field.SetValue (instance, UInt32Enum.MaxValue);
842 Assert.AreEqual (UInt32.MaxValue, instance.field_Int64);
843 field.SetValue (instance, Int64Enum.MaxValue);
844 Assert.AreEqual (Int64.MaxValue, instance.field_Int64);
845 Throws (field, instance, UInt64Enum.MaxValue);
846 field = fh.GetField ("field_UInt64");
847 field.SetValue (instance, Byte.MaxValue);
848 Assert.AreEqual (Byte.MaxValue, instance.field_UInt64);
849 Throws (field, instance, SByte.MaxValue);
850 Throws (field, instance, true);
851 field.SetValue (instance, Char.MaxValue);
852 Assert.AreEqual (Char.MaxValue, instance.field_UInt64);
853 Throws (field, instance, Int16.MaxValue);
854 field.SetValue (instance, UInt16.MaxValue);
855 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt64);
856 Throws (field, instance, Int32.MaxValue);
857 field.SetValue (instance, UInt32.MaxValue);
858 Assert.AreEqual (UInt32.MaxValue, instance.field_UInt64);
859 Throws (field, instance, Int64.MaxValue);
860 field.SetValue (instance, UInt64.MaxValue);
861 Assert.AreEqual (UInt64.MaxValue, instance.field_UInt64);
862 Throws (field, instance, Single.MaxValue);
863 Throws (field, instance, Double.MaxValue);
864 Throws (field, instance, IntPtr.Zero);
865 Throws (field, instance, UIntPtr.Zero);
866 Throws (field, instance, Decimal.MaxValue);
867 Throws (field, instance, DateTime.MaxValue);
868 field.SetValue (instance, ByteEnum.MaxValue);
869 Assert.AreEqual (Byte.MaxValue, instance.field_UInt64);
870 Throws (field, instance, SByteEnum.MaxValue);
871 Throws (field, instance, Int16Enum.MaxValue);
872 field.SetValue (instance, UInt16Enum.MaxValue);
873 Assert.AreEqual (UInt16.MaxValue, instance.field_UInt64);
874 Throws (field, instance, Int32Enum.MaxValue);
875 field.SetValue (instance, UInt32Enum.MaxValue);
876 Assert.AreEqual (UInt32.MaxValue, instance.field_UInt64);
877 Throws (field, instance, Int64Enum.MaxValue);
878 field.SetValue (instance, UInt64Enum.MaxValue);
879 Assert.AreEqual (UInt64.MaxValue, instance.field_UInt64);
880 field = fh.GetField ("field_Single");
881 field.SetValue (instance, Byte.MaxValue);
882 Assert.AreEqual (Byte.MaxValue, instance.field_Single);
883 field.SetValue (instance, SByte.MaxValue);
884 Assert.AreEqual (SByte.MaxValue, instance.field_Single);
885 Throws (field, instance, true);
886 field.SetValue (instance, Char.MaxValue);
887 Assert.AreEqual ((Single) Char.MaxValue, instance.field_Single);
888 field.SetValue (instance, Int16.MaxValue);
889 Assert.AreEqual (Int16.MaxValue, instance.field_Single);
890 field.SetValue (instance, UInt16.MaxValue);
891 Assert.AreEqual (UInt16.MaxValue, instance.field_Single);
892 field.SetValue (instance, Int32.MaxValue);
893 Assert.AreEqual ((Single)Int32.MaxValue, instance.field_Single);
894 field.SetValue (instance, UInt32.MaxValue);
895 Assert.AreEqual ((Single) UInt32.MaxValue, instance.field_Single);
896 field.SetValue (instance, Int64.MaxValue);
897 Assert.AreEqual (Int64.MaxValue, instance.field_Single);
898 field.SetValue (instance, UInt64.MaxValue);
899 Assert.AreEqual (UInt64.MaxValue, instance.field_Single);
900 field.SetValue (instance, Single.MaxValue);
901 Assert.AreEqual (Single.MaxValue, instance.field_Single);
902 Throws (field, instance, Double.MaxValue);
903 Throws (field, instance, IntPtr.Zero);
904 Throws (field, instance, UIntPtr.Zero);
905 Throws (field, instance, Decimal.MaxValue);
906 Throws (field, instance, DateTime.MaxValue);
907 field.SetValue (instance, ByteEnum.MaxValue);
908 Assert.AreEqual (Byte.MaxValue, instance.field_Single);
909 field.SetValue (instance, SByteEnum.MaxValue);
910 Assert.AreEqual (SByte.MaxValue, instance.field_Single);
911 field.SetValue (instance, Int16Enum.MaxValue);
912 Assert.AreEqual (Int16.MaxValue, instance.field_Single);
913 field.SetValue (instance, UInt16Enum.MaxValue);
914 Assert.AreEqual (UInt16.MaxValue, instance.field_Single);
915 field.SetValue (instance, Int32Enum.MaxValue);
916 Assert.AreEqual ((Single) Int32.MaxValue, instance.field_Single);
917 field.SetValue (instance, UInt32Enum.MaxValue);
918 Assert.AreEqual ((Single) UInt32.MaxValue, instance.field_Single);
919 field.SetValue (instance, Int64Enum.MaxValue);
920 Assert.AreEqual (Int64.MaxValue, instance.field_Single);
921 field.SetValue (instance, UInt64Enum.MaxValue);
922 Assert.AreEqual (UInt64.MaxValue, instance.field_Single);
923 field = fh.GetField ("field_Double");
924 field.SetValue (instance, Byte.MaxValue);
925 Assert.AreEqual (Byte.MaxValue, instance.field_Double);
926 field.SetValue (instance, SByte.MaxValue);
927 Assert.AreEqual (SByte.MaxValue, instance.field_Double);
928 Throws (field, instance, true);
929 field.SetValue (instance, Char.MaxValue);
930 Assert.AreEqual ((Double) Char.MaxValue, instance.field_Double);
931 field.SetValue (instance, Int16.MaxValue);
932 Assert.AreEqual (Int16.MaxValue, instance.field_Double);
933 field.SetValue (instance, UInt16.MaxValue);
934 Assert.AreEqual (UInt16.MaxValue, instance.field_Double);
935 field.SetValue (instance, Int32.MaxValue);
936 Assert.AreEqual (Int32.MaxValue, instance.field_Double);
937 field.SetValue (instance, UInt32.MaxValue);
938 Assert.AreEqual (UInt32.MaxValue, instance.field_Double);
939 field.SetValue (instance, Int64.MaxValue);
940 Assert.AreEqual (Int64.MaxValue, instance.field_Double);
941 field.SetValue (instance, UInt64.MaxValue);
942 Assert.AreEqual (UInt64.MaxValue, instance.field_Double);
943 field.SetValue (instance, Single.MaxValue);
944 Assert.AreEqual (Single.MaxValue, instance.field_Double);
945 field.SetValue (instance, Double.MaxValue);
946 Assert.AreEqual (Double.MaxValue, instance.field_Double);
947 Throws (field, instance, IntPtr.Zero);
948 Throws (field, instance, UIntPtr.Zero);
949 Throws (field, instance, Decimal.MaxValue);
950 Throws (field, instance, DateTime.MaxValue);
951 field.SetValue (instance, ByteEnum.MaxValue);
952 Assert.AreEqual (Byte.MaxValue, instance.field_Double);
953 field.SetValue (instance, SByteEnum.MaxValue);
954 Assert.AreEqual (SByte.MaxValue, instance.field_Double);
955 field.SetValue (instance, Int16Enum.MaxValue);
956 Assert.AreEqual (Int16.MaxValue, instance.field_Double);
957 field.SetValue (instance, UInt16Enum.MaxValue);
958 Assert.AreEqual (UInt16.MaxValue, instance.field_Double);
959 field.SetValue (instance, Int32Enum.MaxValue);
960 Assert.AreEqual (Int32.MaxValue, instance.field_Double);
961 field.SetValue (instance, UInt32Enum.MaxValue);
962 Assert.AreEqual (UInt32.MaxValue, instance.field_Double);
963 field.SetValue (instance, Int64Enum.MaxValue);
964 Assert.AreEqual (Int64.MaxValue, instance.field_Double);
965 field.SetValue (instance, UInt64Enum.MaxValue);
966 Assert.AreEqual (UInt64.MaxValue, instance.field_Double);
967 field = fh.GetField ("field_IntPtr");
968 Throws (field, instance, Byte.MaxValue);
969 Throws (field, instance, SByte.MaxValue);
970 Throws (field, instance, true);
971 Throws (field, instance, Char.MaxValue);
972 Throws (field, instance, Int16.MaxValue);
973 Throws (field, instance, UInt16.MaxValue);
974 Throws (field, instance, Int32.MaxValue);
975 Throws (field, instance, UInt32.MaxValue);
976 Throws (field, instance, Int64.MaxValue);
977 Throws (field, instance, UInt64.MaxValue);
978 Throws (field, instance, Single.MaxValue);
979 Throws (field, instance, Double.MaxValue);
980 field.SetValue (instance, IntPtr.Zero);
981 Assert.AreEqual (IntPtr.Zero, instance.field_IntPtr);
982 Throws (field, instance, UIntPtr.Zero);
983 Throws (field, instance, Decimal.MaxValue);
984 Throws (field, instance, DateTime.MaxValue);
985 Throws (field, instance, ByteEnum.MaxValue);
986 Throws (field, instance, SByteEnum.MaxValue);
987 Throws (field, instance, Int16Enum.MaxValue);
988 Throws (field, instance, UInt16Enum.MaxValue);
989 Throws (field, instance, Int32Enum.MaxValue);
990 Throws (field, instance, UInt32Enum.MaxValue);
991 Throws (field, instance, Int64Enum.MaxValue);
992 Throws (field, instance, UInt64Enum.MaxValue);
993 field = fh.GetField ("field_UIntPtr");
994 Throws (field, instance, Byte.MaxValue);
995 Throws (field, instance, SByte.MaxValue);
996 Throws (field, instance, true);
997 Throws (field, instance, Char.MaxValue);
998 Throws (field, instance, Int16.MaxValue);
999 Throws (field, instance, UInt16.MaxValue);
1000 Throws (field, instance, Int32.MaxValue);
1001 Throws (field, instance, UInt32.MaxValue);
1002 Throws (field, instance, Int64.MaxValue);
1003 Throws (field, instance, UInt64.MaxValue);
1004 Throws (field, instance, Single.MaxValue);
1005 Throws (field, instance, Double.MaxValue);
1006 Throws (field, instance, IntPtr.Zero);
1007 field.SetValue (instance, UIntPtr.Zero);
1008 Assert.AreEqual (UIntPtr.Zero, instance.field_UIntPtr);
1009 Throws (field, instance, Decimal.MaxValue);
1010 Throws (field, instance, DateTime.MaxValue);
1011 Throws (field, instance, ByteEnum.MaxValue);
1012 Throws (field, instance, SByteEnum.MaxValue);
1013 Throws (field, instance, Int16Enum.MaxValue);
1014 Throws (field, instance, UInt16Enum.MaxValue);
1015 Throws (field, instance, Int32Enum.MaxValue);
1016 Throws (field, instance, UInt32Enum.MaxValue);
1017 Throws (field, instance, Int64Enum.MaxValue);
1018 Throws (field, instance, UInt64Enum.MaxValue);
1019 field = fh.GetField ("field_Decimal");
1020 Throws (field, instance, Byte.MaxValue);
1021 Throws (field, instance, SByte.MaxValue);
1022 Throws (field, instance, true);
1023 Throws (field, instance, Char.MaxValue);
1024 Throws (field, instance, Int16.MaxValue);
1025 Throws (field, instance, UInt16.MaxValue);
1026 Throws (field, instance, Int32.MaxValue);
1027 Throws (field, instance, UInt32.MaxValue);
1028 Throws (field, instance, Int64.MaxValue);
1029 Throws (field, instance, UInt64.MaxValue);
1030 Throws (field, instance, Single.MaxValue);
1031 Throws (field, instance, Double.MaxValue);
1032 Throws (field, instance, IntPtr.Zero);
1033 Throws (field, instance, UIntPtr.Zero);
1034 field.SetValue (instance, Decimal.MaxValue);
1035 Assert.AreEqual (Decimal.MaxValue, instance.field_Decimal);
1036 Throws (field, instance, DateTime.MaxValue);
1037 Throws (field, instance, ByteEnum.MaxValue);
1038 Throws (field, instance, SByteEnum.MaxValue);
1039 Throws (field, instance, Int16Enum.MaxValue);
1040 Throws (field, instance, UInt16Enum.MaxValue);
1041 Throws (field, instance, Int32Enum.MaxValue);
1042 Throws (field, instance, UInt32Enum.MaxValue);
1043 Throws (field, instance, Int64Enum.MaxValue);
1044 Throws (field, instance, UInt64Enum.MaxValue);
1045 field = fh.GetField ("field_DateTime");
1046 Throws (field, instance, Byte.MaxValue);
1047 Throws (field, instance, SByte.MaxValue);
1048 Throws (field, instance, true);
1049 Throws (field, instance, Char.MaxValue);
1050 Throws (field, instance, Int16.MaxValue);
1051 Throws (field, instance, UInt16.MaxValue);
1052 Throws (field, instance, Int32.MaxValue);
1053 Throws (field, instance, UInt32.MaxValue);
1054 Throws (field, instance, Int64.MaxValue);
1055 Throws (field, instance, UInt64.MaxValue);
1056 Throws (field, instance, Single.MaxValue);
1057 Throws (field, instance, Double.MaxValue);
1058 Throws (field, instance, IntPtr.Zero);
1059 Throws (field, instance, UIntPtr.Zero);
1060 Throws (field, instance, Decimal.MaxValue);
1061 field.SetValue (instance, DateTime.MaxValue);
1062 Assert.AreEqual (DateTime.MaxValue, instance.field_DateTime);
1063 Throws (field, instance, ByteEnum.MaxValue);
1064 Throws (field, instance, SByteEnum.MaxValue);
1065 Throws (field, instance, Int16Enum.MaxValue);
1066 Throws (field, instance, UInt16Enum.MaxValue);
1067 Throws (field, instance, Int32Enum.MaxValue);
1068 Throws (field, instance, UInt32Enum.MaxValue);
1069 Throws (field, instance, Int64Enum.MaxValue);
1070 Throws (field, instance, UInt64Enum.MaxValue);
1071 field = fh.GetField ("field_ByteEnum");
1072 field.SetValue (instance, Byte.MaxValue);
1073 Assert.AreEqual (ByteEnum.MaxValue, instance.field_ByteEnum);
1074 Throws (field, instance, SByte.MaxValue);
1075 Throws (field, instance, true);
1076 Throws (field, instance, Char.MaxValue);
1077 Throws (field, instance, Int16.MaxValue);
1078 Throws (field, instance, UInt16.MaxValue);
1079 Throws (field, instance, Int32.MaxValue);
1080 Throws (field, instance, UInt32.MaxValue);
1081 Throws (field, instance, Int64.MaxValue);
1082 Throws (field, instance, UInt64.MaxValue);
1083 Throws (field, instance, Single.MaxValue);
1084 Throws (field, instance, Double.MaxValue);
1085 Throws (field, instance, IntPtr.Zero);
1086 Throws (field, instance, UIntPtr.Zero);
1087 Throws (field, instance, Decimal.MaxValue);
1088 Throws (field, instance, DateTime.MaxValue);
1089 field.SetValue (instance, ByteEnum.MaxValue);
1090 Assert.AreEqual (ByteEnum.MaxValue, instance.field_ByteEnum);
1091 Throws (field, instance, SByteEnum.MaxValue);
1092 Throws (field, instance, Int16Enum.MaxValue);
1093 Throws (field, instance, UInt16Enum.MaxValue);
1094 Throws (field, instance, Int32Enum.MaxValue);
1095 Throws (field, instance, UInt32Enum.MaxValue);
1096 Throws (field, instance, Int64Enum.MaxValue);
1097 Throws (field, instance, UInt64Enum.MaxValue);
1098 field = fh.GetField ("field_SByteEnum");
1099 Throws (field, instance, Byte.MaxValue);
1100 field.SetValue (instance, SByte.MaxValue);
1101 Assert.AreEqual (SByteEnum.MaxValue, instance.field_SByteEnum);
1102 Throws (field, instance, true);
1103 Throws (field, instance, Char.MaxValue);
1104 Throws (field, instance, Int16.MaxValue);
1105 Throws (field, instance, UInt16.MaxValue);
1106 Throws (field, instance, Int32.MaxValue);
1107 Throws (field, instance, UInt32.MaxValue);
1108 Throws (field, instance, Int64.MaxValue);
1109 Throws (field, instance, UInt64.MaxValue);
1110 Throws (field, instance, Single.MaxValue);
1111 Throws (field, instance, Double.MaxValue);
1112 Throws (field, instance, IntPtr.Zero);
1113 Throws (field, instance, UIntPtr.Zero);
1114 Throws (field, instance, Decimal.MaxValue);
1115 Throws (field, instance, DateTime.MaxValue);
1116 Throws (field, instance, ByteEnum.MaxValue);
1117 field.SetValue (instance, SByteEnum.MaxValue);
1118 Assert.AreEqual (SByteEnum.MaxValue, instance.field_SByteEnum);
1119 Throws (field, instance, Int16Enum.MaxValue);
1120 Throws (field, instance, UInt16Enum.MaxValue);
1121 Throws (field, instance, Int32Enum.MaxValue);
1122 Throws (field, instance, UInt32Enum.MaxValue);
1123 Throws (field, instance, Int64Enum.MaxValue);
1124 Throws (field, instance, UInt64Enum.MaxValue);
1125 field = fh.GetField ("field_Int16Enum");
1126 field.SetValue (instance, Byte.MaxValue);
1127 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int16Enum);
1128 field.SetValue (instance, SByte.MaxValue);
1129 Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int16Enum);
1130 Throws (field, instance, true);
1131 Throws (field, instance, Char.MaxValue);
1132 field.SetValue (instance, Int16.MaxValue);
1133 Assert.AreEqual (Int16Enum.MaxValue, instance.field_Int16Enum);
1134 Throws (field, instance, UInt16.MaxValue);
1135 Throws (field, instance, Int32.MaxValue);
1136 Throws (field, instance, UInt32.MaxValue);
1137 Throws (field, instance, Int64.MaxValue);
1138 Throws (field, instance, UInt64.MaxValue);
1139 Throws (field, instance, Single.MaxValue);
1140 Throws (field, instance, Double.MaxValue);
1141 Throws (field, instance, IntPtr.Zero);
1142 Throws (field, instance, UIntPtr.Zero);
1143 Throws (field, instance, Decimal.MaxValue);
1144 Throws (field, instance, DateTime.MaxValue);
1145 field.SetValue (instance, ByteEnum.MaxValue);
1146 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int16Enum);
1147 field.SetValue (instance, SByteEnum.MaxValue);
1148 Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int16Enum);
1149 field.SetValue (instance, Int16Enum.MaxValue);
1150 Assert.AreEqual (Int16Enum.MaxValue, instance.field_Int16Enum);
1151 Throws (field, instance, UInt16Enum.MaxValue);
1152 Throws (field, instance, Int32Enum.MaxValue);
1153 Throws (field, instance, UInt32Enum.MaxValue);
1154 Throws (field, instance, Int64Enum.MaxValue);
1155 Throws (field, instance, UInt64Enum.MaxValue);
1156 field = fh.GetField ("field_UInt16Enum");
1157 field.SetValue (instance, Byte.MaxValue);
1158 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt16Enum);
1159 Throws (field, instance, SByte.MaxValue);
1160 Throws (field, instance, true);
1161 field.SetValue (instance, Char.MaxValue);
1162 Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt16Enum);
1163 Throws (field, instance, Int16.MaxValue);
1164 field.SetValue (instance, UInt16.MaxValue);
1165 Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt16Enum);
1166 Throws (field, instance, Int32.MaxValue);
1167 Throws (field, instance, UInt32.MaxValue);
1168 Throws (field, instance, Int64.MaxValue);
1169 Throws (field, instance, UInt64.MaxValue);
1170 Throws (field, instance, Single.MaxValue);
1171 Throws (field, instance, Double.MaxValue);
1172 Throws (field, instance, IntPtr.Zero);
1173 Throws (field, instance, UIntPtr.Zero);
1174 Throws (field, instance, Decimal.MaxValue);
1175 Throws (field, instance, DateTime.MaxValue);
1176 field.SetValue (instance, ByteEnum.MaxValue);
1177 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt16Enum);
1178 Throws (field, instance, SByteEnum.MaxValue);
1179 Throws (field, instance, Int16Enum.MaxValue);
1180 field.SetValue (instance, UInt16Enum.MaxValue);
1181 Assert.AreEqual (UInt16Enum.MaxValue, instance.field_UInt16Enum);
1182 Throws (field, instance, Int32Enum.MaxValue);
1183 Throws (field, instance, UInt32Enum.MaxValue);
1184 Throws (field, instance, Int64Enum.MaxValue);
1185 Throws (field, instance, UInt64Enum.MaxValue);
1186 field = fh.GetField ("field_Int32Enum");
1187 field.SetValue (instance, Byte.MaxValue);
1188 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int32Enum);
1189 field.SetValue (instance, SByte.MaxValue);
1190 Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int32Enum);
1191 Throws (field, instance, true);
1192 field.SetValue (instance, Char.MaxValue);
1193 Assert.AreEqual (Char.MaxValue, (char) instance.field_Int32Enum);
1194 field.SetValue (instance, Int16.MaxValue);
1195 Assert.AreEqual (Int16.MaxValue, (Int16) instance.field_Int32Enum);
1196 field.SetValue (instance, UInt16.MaxValue);
1197 Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_Int32Enum);
1198 field.SetValue (instance, Int32.MaxValue);
1199 Assert.AreEqual (Int32.MaxValue, (Int32) instance.field_Int32Enum);
1200 Throws (field, instance, UInt32.MaxValue);
1201 Throws (field, instance, Int64.MaxValue);
1202 Throws (field, instance, UInt64.MaxValue);
1203 Throws (field, instance, Single.MaxValue);
1204 Throws (field, instance, Double.MaxValue);
1205 Throws (field, instance, IntPtr.Zero);
1206 Throws (field, instance, UIntPtr.Zero);
1207 Throws (field, instance, Decimal.MaxValue);
1208 Throws (field, instance, DateTime.MaxValue);
1209 field.SetValue (instance, ByteEnum.MaxValue);
1210 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int32Enum);
1211 field.SetValue (instance, SByteEnum.MaxValue);
1212 Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int32Enum);
1213 field.SetValue (instance, Int16Enum.MaxValue);
1214 Assert.AreEqual (Int16Enum.MaxValue, (Int16Enum) instance.field_Int32Enum);
1215 field.SetValue (instance, UInt16Enum.MaxValue);
1216 Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_Int32Enum);
1217 field.SetValue (instance, Int32Enum.MaxValue);
1218 Assert.AreEqual (Int32Enum.MaxValue, instance.field_Int32Enum);
1219 Throws (field, instance, UInt32Enum.MaxValue);
1220 Throws (field, instance, Int64Enum.MaxValue);
1221 Throws (field, instance, UInt64Enum.MaxValue);
1222 field = fh.GetField ("field_UInt32Enum");
1223 field.SetValue (instance, Byte.MaxValue);
1224 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt32Enum);
1225 Throws (field, instance, SByte.MaxValue);
1226 Throws (field, instance, true);
1227 field.SetValue (instance, Char.MaxValue);
1228 Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt32Enum);
1229 Throws (field, instance, Int16.MaxValue);
1230 field.SetValue (instance, UInt16.MaxValue);
1231 Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt32Enum);
1232 Throws (field, instance, Int32.MaxValue);
1233 field.SetValue (instance, UInt32.MaxValue);
1234 Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_UInt32Enum);
1235 Throws (field, instance, Int64.MaxValue);
1236 Throws (field, instance, UInt64.MaxValue);
1237 Throws (field, instance, Single.MaxValue);
1238 Throws (field, instance, Double.MaxValue);
1239 Throws (field, instance, IntPtr.Zero);
1240 Throws (field, instance, UIntPtr.Zero);
1241 Throws (field, instance, Decimal.MaxValue);
1242 Throws (field, instance, DateTime.MaxValue);
1243 field.SetValue (instance, ByteEnum.MaxValue);
1244 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt32Enum);
1245 Throws (field, instance, SByteEnum.MaxValue);
1246 Throws (field, instance, Int16Enum.MaxValue);
1247 field.SetValue (instance, UInt16Enum.MaxValue);
1248 Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_UInt32Enum);
1249 Throws (field, instance, Int32Enum.MaxValue);
1250 field.SetValue (instance, UInt32Enum.MaxValue);
1251 Assert.AreEqual (UInt32Enum.MaxValue, instance.field_UInt32Enum);
1252 Throws (field, instance, Int64Enum.MaxValue);
1253 Throws (field, instance, UInt64Enum.MaxValue);
1254 field = fh.GetField ("field_Int64Enum");
1255 field.SetValue (instance, Byte.MaxValue);
1256 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int64Enum);
1257 field.SetValue (instance, SByte.MaxValue);
1258 Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int64Enum);
1259 Throws (field, instance, true);
1260 field.SetValue (instance, Char.MaxValue);
1261 Assert.AreEqual (Char.MaxValue, (char) instance.field_Int64Enum);
1262 field.SetValue (instance, Int16.MaxValue);
1263 Assert.AreEqual (Int16.MaxValue, (Int16) instance.field_Int64Enum);
1264 field.SetValue (instance, UInt16.MaxValue);
1265 Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_Int64Enum);
1266 field.SetValue (instance, Int32.MaxValue);
1267 Assert.AreEqual (Int32.MaxValue, (Int32) instance.field_Int64Enum);
1268 field.SetValue (instance, UInt32.MaxValue);
1269 Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_Int64Enum);
1270 field.SetValue (instance, Int64.MaxValue);
1271 Assert.AreEqual (Int64.MaxValue, (Int64) instance.field_Int64Enum);
1272 Throws (field, instance, UInt64.MaxValue);
1273 Throws (field, instance, Single.MaxValue);
1274 Throws (field, instance, Double.MaxValue);
1275 Throws (field, instance, IntPtr.Zero);
1276 Throws (field, instance, UIntPtr.Zero);
1277 Throws (field, instance, Decimal.MaxValue);
1278 Throws (field, instance, DateTime.MaxValue);
1279 field.SetValue (instance, ByteEnum.MaxValue);
1280 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int64Enum);
1281 field.SetValue (instance, SByteEnum.MaxValue);
1282 Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int64Enum);
1283 field.SetValue (instance, Int16Enum.MaxValue);
1284 Assert.AreEqual (Int16Enum.MaxValue, (Int16Enum) instance.field_Int64Enum);
1285 field.SetValue (instance, UInt16Enum.MaxValue);
1286 Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_Int64Enum);
1287 field.SetValue (instance, Int32Enum.MaxValue);
1288 Assert.AreEqual (Int32Enum.MaxValue, (Int32Enum) instance.field_Int64Enum);
1289 field.SetValue (instance, UInt32Enum.MaxValue);
1290 Assert.AreEqual (UInt32Enum.MaxValue, (UInt32Enum) instance.field_Int64Enum);
1291 field.SetValue (instance, Int64Enum.MaxValue);
1292 Assert.AreEqual (Int64Enum.MaxValue, instance.field_Int64Enum);
1293 Throws (field, instance, UInt64Enum.MaxValue);
1294 field = fh.GetField ("field_UInt64Enum");
1295 field.SetValue (instance, Byte.MaxValue);
1296 Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt64Enum);
1297 Throws (field, instance, SByte.MaxValue);
1298 Throws (field, instance, true);
1299 field.SetValue (instance, Char.MaxValue);
1300 Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt64Enum);
1301 Throws (field, instance, Int16.MaxValue);
1302 field.SetValue (instance, UInt16.MaxValue);
1303 Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt64Enum);
1304 Throws (field, instance, Int32.MaxValue);
1305 field.SetValue (instance, UInt32.MaxValue);
1306 Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_UInt64Enum);
1307 Throws (field, instance, Int64.MaxValue);
1308 field.SetValue (instance, UInt64.MaxValue);
1309 Assert.AreEqual (UInt64.MaxValue, (UInt64) instance.field_UInt64Enum);
1310 Throws (field, instance, Single.MaxValue);
1311 Throws (field, instance, Double.MaxValue);
1312 Throws (field, instance, IntPtr.Zero);
1313 Throws (field, instance, UIntPtr.Zero);
1314 Throws (field, instance, Decimal.MaxValue);
1315 Throws (field, instance, DateTime.MaxValue);
1316 field.SetValue (instance, ByteEnum.MaxValue);
1317 Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt64Enum);
1318 Throws (field, instance, SByteEnum.MaxValue);
1319 Throws (field, instance, Int16Enum.MaxValue);
1320 field.SetValue (instance, UInt16Enum.MaxValue);
1321 Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_UInt64Enum);
1322 Throws (field, instance, Int32Enum.MaxValue);
1323 field.SetValue (instance, UInt32Enum.MaxValue);
1324 Assert.AreEqual (UInt32Enum.MaxValue, (UInt32Enum) instance.field_UInt64Enum);
1325 Throws (field, instance, Int64Enum.MaxValue);
1326 field.SetValue (instance, UInt64Enum.MaxValue);
1327 Assert.AreEqual (UInt64Enum.MaxValue, instance.field_UInt64Enum);
1328
1329 }
1330
1331 static void Throws (FieldInfo field, object instance, object value)
1332 {
1333 try {
1334 field.SetValue (instance, value);
1335 Assert.Fail ("ArgumentException expected");
1336 } catch (ArgumentException ex) {
1337 }
1338 }
1339
1340 public object[] ObjectArrayField;
1341
1342 [Test]
1343 public void TestSetValueArray ()
1344 {
1345 var field = typeof (FieldInfoTest).GetField ("ObjectArrayField");
1346 var instance = new FieldInfoTest ();
1347 field.SetValue (instance, new string[] { "3" });
1348 field.SetValue (instance, null);
1349
1350 Throws (field, instance, new int[] { 3 });
1351 }
1352
1353 struct TestFields {
1354 public int MaxValue;
1355 public string str;
1356 }
1357
1358 [Test]
1359 public void SetValueDirect ()
1360 {
1361 TestFields fields = new TestFields { MaxValue = 1234, str = "A" };
1362
1363 FieldInfo info = fields.GetType ().GetField ("MaxValue");
1364 TypedReference reference = __makeref(fields);
1365 info.SetValueDirect (reference, 4096);
1366 Assert.AreEqual (4096, fields.MaxValue);
1367
1368 info = fields.GetType ().GetField ("str");
1369 reference = __makeref(fields);
1370 info.SetValueDirect (reference, "B");
1371 Assert.AreEqual ("B", fields.str);
1372 }
1373
1374 [Test]
1375 public void GetValueContextBoundObject ()
1376 {
1377 var instance = new CBOTest ();
1378
1379 var field1 = typeof (CBOTest).GetField ("d1");
1380 var d1 = field1.GetValue (instance);
1381 Assert.AreEqual ((double)d1, 14.0, "d1");
1382
1383 var field2 = typeof (CBOTest).GetField ("d2");
1384 var d2 = field2.GetValue (instance);
1385 Assert.AreEqual ((double)d2, -20, "d2");
1386
1387 var field3 = typeof (CBOTest).GetField ("s1");
1388 var s1 = field3.GetValue (instance);
1389 Assert.AreEqual (s1, "abcd", "s1");
1390
1391 var field4 = typeof (CBOTest).GetField ("s2");
1392 var s2 = field4.GetValue (instance);
1393 Assert.AreEqual (s2, "hijkl", "s2");
1394 }
1395
1396 [Test]
1397 public void SetValueContextBoundObject ()
1398 {
1399 var instance = new CBOTest ();
1400
1401 var field1 = typeof (CBOTest).GetField ("d1");
1402 field1.SetValue (instance, 90.3);
1403 var d1 = field1.GetValue (instance);
1404 Assert.AreEqual ((double)d1, 90.3, "d1");
1405
1406 var field2 = typeof (CBOTest).GetField ("d2");
1407 field2.SetValue (instance, 1);
1408 var d2 = field2.GetValue (instance);
1409 Assert.AreEqual ((double)d2, 1, "d2");
1410
1411 var field3 = typeof (CBOTest).GetField ("s1");
1412 field3.SetValue (instance, "//////");
1413 var s1 = field3.GetValue (instance);
1414 Assert.AreEqual (s1, "//////", "s1");
1415
1416 var field4 = typeof (CBOTest).GetField ("s2");
1417 field4.SetValue (instance, "This is a string");
1418 var s2 = field4.GetValue (instance);
1419 Assert.AreEqual (s2, "This is a string", "s2");
1420
1421 }
1422
1423 class CBOTest : ContextBoundObject {
1424 public double d1 = 14.0;
1425 public double d2 = -20.0;
1426 public string s1 = "abcd";
1427 public string s2 = "hijkl";
1428 }
1429
1430
1431 public IntEnum PPP;
1432
1433 public class Foo<T>
1434 {
1435 /*
1436 The whole point of this field is to make sure we don't create the vtable layout
1437 when loading the value of constants for Foo<>. See bug #594942.
1438
1439 */
1440 public T dummy;
1441 public static int field;
1442 public const int constant = 10;
1443 public const string sconstant = "waa";
1444 public const IntEnum econstant = IntEnum.Third;
1445 }
1446
1447 public enum IntEnum {
1448 First = 1,
1449 Second = 2,
1450 Third = 3
1451 }
1452
1453 public enum LongEnum : long {
1454 First = 1,
1455 Second = 2,
1456 Third = 3
1457 }
1458
1459 public const int int_field = 5;
1460 public const long long_field = Int64.MaxValue;
1461 public const IntEnum int_enum_field = IntEnum.Second;
1462 public const LongEnum long_enum_field = LongEnum.Second;
1463 public const string string_field = "Hello";
1464 public const FieldInfoTest object_field = null;
1465 public int non_const_field;
1466
1467 class FieldInfoWrapper : FieldInfo
1468 {
1469 private FieldInfo fieldInfo;
1470
1471 public FieldInfoWrapper (FieldInfo fieldInfo)
1472 {
1473 this.fieldInfo = fieldInfo;
1474 }
1475
1476 public override FieldAttributes Attributes => fieldInfo.Attributes;
1477 public override Type DeclaringType => fieldInfo.DeclaringType;
1478 public override RuntimeFieldHandle FieldHandle => fieldInfo.FieldHandle;
1479 public override Type FieldType => fieldInfo.FieldType;
1480 public override string Name => fieldInfo.Name;
1481 public override Type ReflectedType => fieldInfo.ReflectedType;
1482
1483 public override object[] GetCustomAttributes (bool inherit) => fieldInfo.GetCustomAttributes (inherit);
1484 public override object[] GetCustomAttributes (Type attributeType, bool inherit) => fieldInfo.GetCustomAttributes (attributeType, inherit);
1485 public override object GetValue (object obj) => fieldInfo.GetValue (obj);
1486 public override bool IsDefined (Type attributeType, bool inherit) => fieldInfo.IsDefined (attributeType, inherit);
1487 public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) =>
1488 fieldInfo.SetValue (obj, value, invokeAttr, binder, culture);
1489 }
1490
1491 [Test]
1492 public void CustomFieldInfo ()
1493 {
1494 var fieldInfoWrapper = new FieldInfoWrapper (GetType ().GetField (nameof (non_const_field)));
1495 MethodInfo method = typeof (FieldInfoWrapper).GetMethod ("GetFieldOffset", BindingFlags.NonPublic | BindingFlags.Instance);
1496 Assert.IsNotNull (method);
1497 Assert.IsTrue (method.IsVirtual);
1498
1499 var ex = Assert.Catch<Exception> (() => method.Invoke (fieldInfoWrapper, new object[] {}));
1500 Assert.IsTrue (ex.InnerException is SystemException);
1501 }
1502 }
1503
1504 // We do not refernece the field, that is expected
1505 #pragma warning disable 169
1506 // Helper classes
1507 class RefOnlyFieldClass
1508 {
1509 // Helper property
1510 static int RefOnlyField;
1511 }
1512 #pragma warning restore 169
1513
1514 class NonPublicFieldClass
1515 {
1516 protected int protectedField;
1517
1518 public void Dummy ()
1519 {
1520 protectedField = 1;
1521 }
1522 }
1523
1524 public class FieldInfoTest<T>
1525 {
1526 public T TestField;
1527 }
1528 }
Mirror of the official Mono project git repository