1485 lines
59 KiB
C#
1485 lines
59 KiB
C#
//
|
|
// FieldInfoTest - NUnit Test Cases for the FieldInfo class
|
|
//
|
|
// Authors:
|
|
// Zoltan Varga (vargaz@freemail.hu)
|
|
// Gert Driesen (drieseng@users.sourceforge.net)
|
|
//
|
|
// (c) 2003 Ximian, Inc. (http://www.ximian.com)
|
|
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Threading;
|
|
using System.Reflection;
|
|
#if !MONOTOUCH && !FULL_AOT_RUNTIME
|
|
using System.Reflection.Emit;
|
|
#endif
|
|
using System.Runtime.InteropServices;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.Reflection
|
|
{
|
|
[StructLayout(LayoutKind.Explicit, Pack = 4, Size = 64)]
|
|
public class Class1
|
|
{
|
|
[FieldOffset (32)]
|
|
public int i;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public class Class2
|
|
{
|
|
[MarshalAsAttribute(UnmanagedType.Bool)]
|
|
public int f0;
|
|
|
|
[MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.LPStr)]
|
|
public string[] f1;
|
|
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=100)]
|
|
public string f2;
|
|
#if FEATURE_COMINTEROP
|
|
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof (Marshal1), MarshalCookie="5")]
|
|
public int f3;
|
|
|
|
[MarshalAs (UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof (Marshal1), MarshalCookie = "5")]
|
|
public object f4;
|
|
#endif
|
|
[Obsolete]
|
|
public int f5;
|
|
}
|
|
|
|
public class Class3 : Class2
|
|
{
|
|
}
|
|
|
|
// Disable this warning, as the purpose of this struct is to poke at the internal via reflection
|
|
#pragma warning disable 649
|
|
class FieldInvokeMatrix
|
|
{
|
|
public Byte field_Byte;
|
|
public SByte field_SByte;
|
|
public Boolean field_Boolean;
|
|
public Char field_Char;
|
|
public Int16 field_Int16;
|
|
public UInt16 field_UInt16;
|
|
public Int32 field_Int32;
|
|
public UInt32 field_UInt32;
|
|
public Int64 field_Int64;
|
|
public UInt64 field_UInt64;
|
|
public Single field_Single;
|
|
public Double field_Double;
|
|
public IntPtr field_IntPtr;
|
|
public UIntPtr field_UIntPtr;
|
|
public Decimal field_Decimal;
|
|
public DateTime field_DateTime;
|
|
public String field_String;
|
|
|
|
public ByteEnum field_ByteEnum;
|
|
public SByteEnum field_SByteEnum;
|
|
public Int16Enum field_Int16Enum;
|
|
public UInt16Enum field_UInt16Enum;
|
|
public Int32Enum field_Int32Enum;
|
|
public UInt32Enum field_UInt32Enum;
|
|
public Int64Enum field_Int64Enum;
|
|
public UInt64Enum field_UInt64Enum;
|
|
}
|
|
#pragma warning restore 649
|
|
|
|
public enum ByteEnum : byte
|
|
{
|
|
MaxValue = Byte.MaxValue
|
|
}
|
|
|
|
public enum SByteEnum : sbyte
|
|
{
|
|
MaxValue = SByte.MaxValue
|
|
}
|
|
|
|
public enum Int16Enum : short
|
|
{
|
|
MaxValue = Int16.MaxValue
|
|
}
|
|
|
|
public enum UInt16Enum : ushort
|
|
{
|
|
MaxValue = UInt16.MaxValue
|
|
}
|
|
|
|
public enum Int32Enum : int
|
|
{
|
|
MaxValue = Int32.MaxValue
|
|
}
|
|
|
|
public enum UInt32Enum: uint
|
|
{
|
|
MaxValue= UInt32.MaxValue
|
|
}
|
|
|
|
public enum Int64Enum : long
|
|
{
|
|
MaxValue = Int64.MaxValue
|
|
}
|
|
|
|
public enum UInt64Enum: ulong
|
|
{
|
|
MaxValue = UInt64.MaxValue
|
|
}
|
|
|
|
[TestFixture]
|
|
public unsafe class FieldInfoTest
|
|
{
|
|
[NonSerialized]
|
|
public int i;
|
|
|
|
[Test]
|
|
public void IsDefined_AttributeType_Null ()
|
|
{
|
|
Type type = typeof (FieldInfoTest);
|
|
FieldInfo field = type.GetField ("i");
|
|
|
|
try {
|
|
field.IsDefined ((Type) null, false);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("attributeType", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void FieldInfoModule ()
|
|
{
|
|
Type type = typeof (FieldInfoTest);
|
|
FieldInfo field = type.GetField ("i");
|
|
|
|
Assert.AreEqual (type.Module, field.Module);
|
|
}
|
|
|
|
[Test]
|
|
public void GetCustomAttributes ()
|
|
{
|
|
object [] attrs;
|
|
FieldInfo fi;
|
|
|
|
fi = typeof (Class2).GetField ("f5");
|
|
|
|
attrs = fi.GetCustomAttributes (false);
|
|
Assert.AreEqual (1, attrs.Length, "#B1");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B2");
|
|
attrs = fi.GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#B3");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B4");
|
|
attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), false);
|
|
Assert.AreEqual (0, attrs.Length, "#B5");
|
|
attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), true);
|
|
Assert.AreEqual (0, attrs.Length, "#B6");
|
|
attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), false);
|
|
Assert.AreEqual (1, attrs.Length, "#B7");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B8");
|
|
attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), true);
|
|
Assert.AreEqual (1, attrs.Length, "#B9");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#B10");
|
|
|
|
fi = typeof (Class3).GetField ("f5");
|
|
|
|
attrs = fi.GetCustomAttributes (false);
|
|
Assert.AreEqual (1, attrs.Length, "#D1");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D2");
|
|
attrs = fi.GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#D3");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D4");
|
|
attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), false);
|
|
Assert.AreEqual (0, attrs.Length, "#D5");
|
|
attrs = fi.GetCustomAttributes (typeof (MarshalAsAttribute), true);
|
|
Assert.AreEqual (0, attrs.Length, "#D6");
|
|
attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), false);
|
|
Assert.AreEqual (1, attrs.Length, "#D7");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D8");
|
|
attrs = fi.GetCustomAttributes (typeof (ObsoleteAttribute), true);
|
|
Assert.AreEqual (1, attrs.Length, "#D9");
|
|
Assert.AreEqual (typeof (ObsoleteAttribute), attrs [0].GetType (), "#D10");
|
|
}
|
|
|
|
[Test] // GetFieldFromHandle (RuntimeFieldHandle)
|
|
public void GetFieldFromHandle1_Handle_Zero ()
|
|
{
|
|
RuntimeFieldHandle fh = new RuntimeFieldHandle ();
|
|
|
|
try {
|
|
FieldInfo.GetFieldFromHandle (fh);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
// Handle is not initialized
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
|
|
public void GetFieldFromHandle2_DeclaringType_Zero ()
|
|
{
|
|
RuntimeTypeHandle th = new RuntimeTypeHandle ();
|
|
FieldInfo fi1 = typeof (Class2).GetField ("f5");
|
|
RuntimeFieldHandle fh = fi1.FieldHandle;
|
|
|
|
FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
|
|
Assert.IsNotNull (fi2, "#1");
|
|
Assert.AreSame (fi1.DeclaringType, fi2.DeclaringType, "#2");
|
|
Assert.AreEqual (fi1.FieldType, fi2.FieldType, "#3");
|
|
Assert.AreEqual (fi1.Name, fi2.Name, "#4");
|
|
}
|
|
|
|
[Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
|
|
public void GetFieldFromHandle2_Handle_Generic ()
|
|
{
|
|
FieldInfoTest<string> instance = new FieldInfoTest<string> ();
|
|
Type t = instance.GetType ();
|
|
|
|
FieldInfo fi1 = t.GetField ("TestField");
|
|
RuntimeFieldHandle fh = fi1.FieldHandle;
|
|
RuntimeTypeHandle th = t.TypeHandle;
|
|
|
|
FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
|
|
Assert.IsNotNull (fi2, "#1");
|
|
Assert.AreSame (t, fi2.DeclaringType, "#2");
|
|
Assert.AreEqual (typeof (string), fi2.FieldType, "#3");
|
|
Assert.AreEqual ("TestField", fi2.Name, "#4");
|
|
}
|
|
|
|
[Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
|
|
[Category ("NotWorking")]
|
|
[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=343449
|
|
public void GetFieldFromHandle2_Handle_GenericDefinition ()
|
|
{
|
|
Type t1 = typeof (FieldInfoTest<>);
|
|
FieldInfo fi1 = t1.GetField ("TestField");
|
|
RuntimeFieldHandle fh = fi1.FieldHandle;
|
|
|
|
FieldInfoTest<string> instance = new FieldInfoTest<string> ();
|
|
Type t2 = instance.GetType ();
|
|
RuntimeTypeHandle th = t2.TypeHandle;
|
|
|
|
FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
|
|
Assert.IsNotNull (fi2, "#1");
|
|
Assert.AreSame (t2, fi2.DeclaringType, "#2");
|
|
Assert.AreEqual (typeof (string), fi2.FieldType, "#3");
|
|
Assert.AreEqual ("TestField", fi2.Name, "#4");
|
|
}
|
|
|
|
[Test] // GetFieldFromHandle (RuntimeFieldHandle, RuntimeTypeHandle)
|
|
public void GetFieldFromHandle2_Handle_Zero ()
|
|
{
|
|
object instance = new Class2 ();
|
|
RuntimeTypeHandle th = Type.GetTypeHandle (instance);
|
|
RuntimeFieldHandle fh = new RuntimeFieldHandle ();
|
|
|
|
try {
|
|
FieldInfo.GetFieldFromHandle (fh, th);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentException ex) {
|
|
// Handle is not initialized
|
|
Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNull (ex.ParamName, "#5");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void GetFieldFromHandle2_Incompatible ()
|
|
{
|
|
RuntimeFieldHandle fh = typeof (FieldInfoTest<int>).GetField ("TestField").FieldHandle;
|
|
|
|
FieldInfoTest<string> instance = new FieldInfoTest<string> ();
|
|
Type t2 = instance.GetType ();
|
|
RuntimeTypeHandle th = t2.TypeHandle;
|
|
|
|
FieldInfo fi2 = FieldInfo.GetFieldFromHandle (fh, th);
|
|
}
|
|
|
|
[Test]
|
|
public void PseudoCustomAttributes ()
|
|
{
|
|
object [] attrs;
|
|
Type t = typeof (FieldInfoTest);
|
|
|
|
Assert.AreEqual (1, t.GetField ("i").GetCustomAttributes (typeof (NonSerializedAttribute), true).Length);
|
|
|
|
attrs = typeof (Class1).GetField ("i").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#B1");
|
|
FieldOffsetAttribute field_attr = (FieldOffsetAttribute) attrs [0];
|
|
Assert.AreEqual (32, field_attr.Value, "#B2");
|
|
|
|
MarshalAsAttribute attr;
|
|
|
|
attrs = typeof (Class2).GetField ("f0").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#C1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.Bool, attr.Value, "#C2");
|
|
|
|
attrs = typeof (Class2).GetField ("f1").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#D1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.LPArray, attr.Value, "#D2");
|
|
Assert.AreEqual (UnmanagedType.LPStr, attr.ArraySubType, "#D3");
|
|
|
|
attrs = typeof (Class2).GetField ("f2").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#E1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.ByValTStr, attr.Value, "#E2");
|
|
Assert.AreEqual (100, attr.SizeConst, "#E3");
|
|
|
|
#if FEATURE_COMINTEROP
|
|
attrs = typeof (Class2).GetField ("f3").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#F1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#F2");
|
|
|
|
Assert.AreEqual ("5", attr.MarshalCookie, "#F3");
|
|
Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#F4");
|
|
|
|
attrs = typeof (Class3).GetField ("f3").GetCustomAttributes (false);
|
|
Assert.AreEqual (1, attrs.Length, "#G1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#G2");
|
|
Assert.AreEqual ("5", attr.MarshalCookie, "#G3");
|
|
Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#G4");
|
|
|
|
attrs = typeof (Class3).GetField ("f3").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#H1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#H2");
|
|
Assert.AreEqual ("5", attr.MarshalCookie, "#H3");
|
|
Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#H4");
|
|
|
|
// bug #82465
|
|
attrs = typeof (Class2).GetField ("f3").GetCustomAttributes (true);
|
|
Assert.AreEqual (1, attrs.Length, "#I1");
|
|
attr = (MarshalAsAttribute) attrs [0];
|
|
Assert.AreEqual (UnmanagedType.CustomMarshaler, attr.Value, "#I2");
|
|
Assert.AreEqual ("5", attr.MarshalCookie, "#I3");
|
|
Assert.AreEqual (typeof (Marshal1), Type.GetType (attr.MarshalType), "#I4");
|
|
#endif
|
|
}
|
|
|
|
// Disable "field not used warning", this is intended.
|
|
#pragma warning disable 649
|
|
class Foo {
|
|
public static int static_field;
|
|
public int field;
|
|
}
|
|
#pragma warning restore 649
|
|
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void GetValueWrongObject ()
|
|
{
|
|
Foo f = new Foo ();
|
|
|
|
typeof (Foo).GetField ("field").GetValue (typeof (int));
|
|
}
|
|
|
|
public void GetValueWrongObjectStatic ()
|
|
{
|
|
Foo f = new Foo ();
|
|
|
|
// This is allowed in MS.NET
|
|
typeof (Foo).GetField ("static_field").GetValue (typeof (int));
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void GetValueOnRefOnlyAssembly ()
|
|
{
|
|
Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
|
|
Type t = assembly.GetType (typeof (RefOnlyFieldClass).FullName);
|
|
FieldInfo f = t.GetField ("RefOnlyField", BindingFlags.Static | BindingFlags.NonPublic);
|
|
f.GetValue (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void SetValueOnRefOnlyAssembly ()
|
|
{
|
|
Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
|
|
Type t = assembly.GetType (typeof (RefOnlyFieldClass).FullName);
|
|
FieldInfo f = t.GetField ("RefOnlyField", BindingFlags.Static | BindingFlags.NonPublic);
|
|
f.SetValue (null, 8);
|
|
}
|
|
|
|
const int literal = 42;
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (FieldAccessException))]
|
|
public void SetValueOnLiteralField ()
|
|
{
|
|
FieldInfo f = typeof (FieldInfoTest).GetField ("literal", BindingFlags.Static | BindingFlags.NonPublic);
|
|
f.SetValue (null, 0);
|
|
}
|
|
|
|
public int? nullable_field;
|
|
|
|
public static int? static_nullable_field;
|
|
|
|
[Test]
|
|
public void NullableTests ()
|
|
{
|
|
FieldInfoTest t = new FieldInfoTest ();
|
|
|
|
FieldInfo fi = typeof (FieldInfoTest).GetField ("nullable_field");
|
|
|
|
fi.SetValue (t, 101);
|
|
Assert.AreEqual (101, fi.GetValue (t));
|
|
fi.SetValue (t, null);
|
|
Assert.AreEqual (null, fi.GetValue (t));
|
|
|
|
FieldInfo fi2 = typeof (FieldInfoTest).GetField ("static_nullable_field");
|
|
|
|
fi2.SetValue (t, 101);
|
|
Assert.AreEqual (101, fi2.GetValue (t));
|
|
fi2.SetValue (t, null);
|
|
Assert.AreEqual (null, fi2.GetValue (t));
|
|
}
|
|
|
|
[Test]
|
|
public void NonPublicTests ()
|
|
{
|
|
Assembly assembly = Assembly.ReflectionOnlyLoad (typeof (FieldInfoTest).Assembly.FullName);
|
|
|
|
Type t = assembly.GetType (typeof (NonPublicFieldClass).FullName);
|
|
|
|
// try to get non-public field
|
|
FieldInfo fi = t.GetField ("protectedField");
|
|
Assert.IsNull (fi);
|
|
// get it for real
|
|
fi = t.GetField ("protectedField", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
Assert.IsNotNull (fi);
|
|
}
|
|
|
|
[Test]
|
|
public void GetRawDefaultValue ()
|
|
{
|
|
Assert.AreEqual (5, typeof (FieldInfoTest).GetField ("int_field").GetRawConstantValue ());
|
|
Assert.AreEqual (Int64.MaxValue, typeof (FieldInfoTest).GetField ("long_field").GetRawConstantValue ());
|
|
Assert.AreEqual (2, typeof (FieldInfoTest).GetField ("int_enum_field").GetRawConstantValue ());
|
|
Assert.AreEqual (typeof (int), typeof (FieldInfoTest).GetField ("int_enum_field").GetRawConstantValue ().GetType ());
|
|
Assert.AreEqual (2, typeof (FieldInfoTest).GetField ("long_enum_field").GetRawConstantValue ());
|
|
Assert.AreEqual (typeof (long), typeof (FieldInfoTest).GetField ("long_enum_field").GetRawConstantValue ().GetType ());
|
|
Assert.AreEqual ("Hello", typeof (FieldInfoTest).GetField ("string_field").GetRawConstantValue ());
|
|
Assert.AreEqual (null, typeof (FieldInfoTest).GetField ("object_field").GetRawConstantValue ());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void GetRawDefaultValueNoDefault ()
|
|
{
|
|
typeof (FieldInfoTest).GetField ("non_const_field").GetRawConstantValue ();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void GetValueOpenGeneric ()
|
|
{
|
|
typeof(Foo<>).GetField ("field").GetValue (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (InvalidOperationException))]
|
|
public void SetValueOpenGeneric ()
|
|
{
|
|
typeof(Foo<>).GetField ("field").SetValue (null, 0);
|
|
}
|
|
|
|
[Test]
|
|
public void GetValueOnConstantOfOpenGeneric ()
|
|
{
|
|
Assert.AreEqual (10, typeof(Foo<>).GetField ("constant").GetValue (null), "#1");
|
|
Assert.AreEqual ("waa", typeof(Foo<>).GetField ("sconstant").GetValue (null), "#2");
|
|
Assert.AreEqual (IntEnum.Third, typeof(Foo<>).GetField ("econstant").GetValue (null), "#3");
|
|
}
|
|
|
|
public static unsafe void* ip;
|
|
|
|
[Test]
|
|
public unsafe void GetSetValuePointers ()
|
|
{
|
|
Pointer p0 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
|
|
int *p0i = (int*)Pointer.Unbox (p0);
|
|
Assert.AreEqual (IntPtr.Zero, new IntPtr (p0i));
|
|
|
|
int i = 5;
|
|
void *p = &i;
|
|
typeof (FieldInfoTest).GetField ("ip").SetValue (null, (IntPtr)p);
|
|
Pointer p2 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
|
|
|
|
int *pi = (int*)Pointer.Unbox (p2);
|
|
Assert.AreEqual (5, *pi);
|
|
|
|
typeof (FieldInfoTest).GetField ("ip").SetValue (null, (UIntPtr)p);
|
|
p2 = (Pointer)typeof (FieldInfoTest).GetField ("ip").GetValue (null);
|
|
|
|
pi = (int*)Pointer.Unbox (p2);
|
|
Assert.AreEqual (5, *pi);
|
|
}
|
|
|
|
[Test]
|
|
public void SetValuePrimitiveConversions ()
|
|
{
|
|
FieldInfo field;
|
|
var instance = new FieldInvokeMatrix ();
|
|
var fh = typeof (FieldInvokeMatrix);
|
|
|
|
field = fh.GetField ("field_Byte");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Byte);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Byte);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_SByte");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_SByte);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_SByte);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Boolean");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
field.SetValue (instance, true);
|
|
Assert.AreEqual (true, instance.field_Boolean);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Char");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Char);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_Char);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Char);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Char);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Char);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int16");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int16);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int16);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int16);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int16);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int16);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int16);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt16");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt16);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_UInt16);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt16);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt16);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt16);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int32");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int32);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Int32);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Int32);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Int32);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt32");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_UInt32);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int64");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int64);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int64.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Int64);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_Int64);
|
|
field.SetValue (instance, Int64Enum.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Int64);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt64");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
field.SetValue (instance, UInt64.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_UInt64);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
field.SetValue (instance, UInt64Enum.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_UInt64);
|
|
field = fh.GetField ("field_Single");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Single);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual ((Single) Char.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual ((Single)Int32.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual ((Single) UInt32.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int64.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt64.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Single.MaxValue);
|
|
Assert.AreEqual (Single.MaxValue, instance.field_Single);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual ((Single) Int32.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual ((Single) UInt32.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, Int64Enum.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Single);
|
|
field.SetValue (instance, UInt64Enum.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_Single);
|
|
field = fh.GetField ("field_Double");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Double);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual ((Double) Char.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int64.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt64.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Single.MaxValue);
|
|
Assert.AreEqual (Single.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Double.MaxValue);
|
|
Assert.AreEqual (Double.MaxValue, instance.field_Double);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, Int64Enum.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, instance.field_Double);
|
|
field.SetValue (instance, UInt64Enum.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, instance.field_Double);
|
|
field = fh.GetField ("field_IntPtr");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
field.SetValue (instance, IntPtr.Zero);
|
|
Assert.AreEqual (IntPtr.Zero, instance.field_IntPtr);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UIntPtr");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
field.SetValue (instance, UIntPtr.Zero);
|
|
Assert.AreEqual (UIntPtr.Zero, instance.field_UIntPtr);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Decimal");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
field.SetValue (instance, Decimal.MaxValue);
|
|
Assert.AreEqual (Decimal.MaxValue, instance.field_Decimal);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_DateTime");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
field.SetValue (instance, DateTime.MaxValue);
|
|
Assert.AreEqual (DateTime.MaxValue, instance.field_DateTime);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_ByteEnum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, instance.field_ByteEnum);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, instance.field_ByteEnum);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_SByteEnum");
|
|
Throws (field, instance, Byte.MaxValue);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByteEnum.MaxValue, instance.field_SByteEnum);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
Throws (field, instance, ByteEnum.MaxValue);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByteEnum.MaxValue, instance.field_SByteEnum);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int16Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int16Enum);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int16Enum);
|
|
Throws (field, instance, true);
|
|
Throws (field, instance, Char.MaxValue);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16Enum.MaxValue, instance.field_Int16Enum);
|
|
Throws (field, instance, UInt16.MaxValue);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int16Enum);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int16Enum);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16Enum.MaxValue, instance.field_Int16Enum);
|
|
Throws (field, instance, UInt16Enum.MaxValue);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt16Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt16Enum);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt16Enum);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt16Enum);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt16Enum);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16Enum.MaxValue, instance.field_UInt16Enum);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int32Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int32Enum);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int32Enum);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, (char) instance.field_Int32Enum);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, (Int16) instance.field_Int32Enum);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_Int32Enum);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, (Int32) instance.field_Int32Enum);
|
|
Throws (field, instance, UInt32.MaxValue);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int32Enum);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int32Enum);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16Enum.MaxValue, (Int16Enum) instance.field_Int32Enum);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_Int32Enum);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual (Int32Enum.MaxValue, instance.field_Int32Enum);
|
|
Throws (field, instance, UInt32Enum.MaxValue);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt32Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt32Enum);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt32Enum);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt32Enum);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_UInt32Enum);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt32Enum);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_UInt32Enum);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32Enum.MaxValue, instance.field_UInt32Enum);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_Int64Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_Int64Enum);
|
|
field.SetValue (instance, SByte.MaxValue);
|
|
Assert.AreEqual (SByte.MaxValue, (sbyte) instance.field_Int64Enum);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, (char) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int16.MaxValue);
|
|
Assert.AreEqual (Int16.MaxValue, (Int16) instance.field_Int64Enum);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int32.MaxValue);
|
|
Assert.AreEqual (Int32.MaxValue, (Int32) instance.field_Int64Enum);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int64.MaxValue);
|
|
Assert.AreEqual (Int64.MaxValue, (Int64) instance.field_Int64Enum);
|
|
Throws (field, instance, UInt64.MaxValue);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_Int64Enum);
|
|
field.SetValue (instance, SByteEnum.MaxValue);
|
|
Assert.AreEqual (SByteEnum.MaxValue, (SByteEnum) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int16Enum.MaxValue);
|
|
Assert.AreEqual (Int16Enum.MaxValue, (Int16Enum) instance.field_Int64Enum);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int32Enum.MaxValue);
|
|
Assert.AreEqual (Int32Enum.MaxValue, (Int32Enum) instance.field_Int64Enum);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32Enum.MaxValue, (UInt32Enum) instance.field_Int64Enum);
|
|
field.SetValue (instance, Int64Enum.MaxValue);
|
|
Assert.AreEqual (Int64Enum.MaxValue, instance.field_Int64Enum);
|
|
Throws (field, instance, UInt64Enum.MaxValue);
|
|
field = fh.GetField ("field_UInt64Enum");
|
|
field.SetValue (instance, Byte.MaxValue);
|
|
Assert.AreEqual (Byte.MaxValue, (byte) instance.field_UInt64Enum);
|
|
Throws (field, instance, SByte.MaxValue);
|
|
Throws (field, instance, true);
|
|
field.SetValue (instance, Char.MaxValue);
|
|
Assert.AreEqual (Char.MaxValue, (char) instance.field_UInt64Enum);
|
|
Throws (field, instance, Int16.MaxValue);
|
|
field.SetValue (instance, UInt16.MaxValue);
|
|
Assert.AreEqual (UInt16.MaxValue, (UInt16) instance.field_UInt64Enum);
|
|
Throws (field, instance, Int32.MaxValue);
|
|
field.SetValue (instance, UInt32.MaxValue);
|
|
Assert.AreEqual (UInt32.MaxValue, (UInt32) instance.field_UInt64Enum);
|
|
Throws (field, instance, Int64.MaxValue);
|
|
field.SetValue (instance, UInt64.MaxValue);
|
|
Assert.AreEqual (UInt64.MaxValue, (UInt64) instance.field_UInt64Enum);
|
|
Throws (field, instance, Single.MaxValue);
|
|
Throws (field, instance, Double.MaxValue);
|
|
Throws (field, instance, IntPtr.Zero);
|
|
Throws (field, instance, UIntPtr.Zero);
|
|
Throws (field, instance, Decimal.MaxValue);
|
|
Throws (field, instance, DateTime.MaxValue);
|
|
field.SetValue (instance, ByteEnum.MaxValue);
|
|
Assert.AreEqual (ByteEnum.MaxValue, (ByteEnum) instance.field_UInt64Enum);
|
|
Throws (field, instance, SByteEnum.MaxValue);
|
|
Throws (field, instance, Int16Enum.MaxValue);
|
|
field.SetValue (instance, UInt16Enum.MaxValue);
|
|
Assert.AreEqual (UInt16Enum.MaxValue, (UInt16Enum) instance.field_UInt64Enum);
|
|
Throws (field, instance, Int32Enum.MaxValue);
|
|
field.SetValue (instance, UInt32Enum.MaxValue);
|
|
Assert.AreEqual (UInt32Enum.MaxValue, (UInt32Enum) instance.field_UInt64Enum);
|
|
Throws (field, instance, Int64Enum.MaxValue);
|
|
field.SetValue (instance, UInt64Enum.MaxValue);
|
|
Assert.AreEqual (UInt64Enum.MaxValue, instance.field_UInt64Enum);
|
|
|
|
}
|
|
|
|
static void Throws (FieldInfo field, object instance, object value)
|
|
{
|
|
try {
|
|
field.SetValue (instance, value);
|
|
Assert.Fail ("ArgumentException expected");
|
|
} catch (ArgumentException ex) {
|
|
}
|
|
}
|
|
|
|
public object[] ObjectArrayField;
|
|
|
|
[Test]
|
|
public void TestSetValueArray ()
|
|
{
|
|
var field = typeof (FieldInfoTest).GetField ("ObjectArrayField");
|
|
var instance = new FieldInfoTest ();
|
|
field.SetValue (instance, new string[] { "3" });
|
|
field.SetValue (instance, null);
|
|
|
|
Throws (field, instance, new int[] { 3 });
|
|
}
|
|
|
|
struct TestFields {
|
|
public int MaxValue;
|
|
public string str;
|
|
}
|
|
|
|
[Test]
|
|
public void SetValueDirect ()
|
|
{
|
|
TestFields fields = new TestFields { MaxValue = 1234, str = "A" };
|
|
|
|
FieldInfo info = fields.GetType ().GetField ("MaxValue");
|
|
TypedReference reference = __makeref(fields);
|
|
info.SetValueDirect (reference, 4096);
|
|
Assert.AreEqual (4096, fields.MaxValue);
|
|
|
|
info = fields.GetType ().GetField ("str");
|
|
reference = __makeref(fields);
|
|
info.SetValueDirect (reference, "B");
|
|
Assert.AreEqual ("B", fields.str);
|
|
}
|
|
|
|
[Test]
|
|
public void GetValueContextBoundObject ()
|
|
{
|
|
var instance = new CBOTest ();
|
|
|
|
var field1 = typeof (CBOTest).GetField ("d1");
|
|
var d1 = field1.GetValue (instance);
|
|
Assert.AreEqual ((double)d1, 14.0, "d1");
|
|
|
|
var field2 = typeof (CBOTest).GetField ("d2");
|
|
var d2 = field2.GetValue (instance);
|
|
Assert.AreEqual ((double)d2, -20, "d2");
|
|
|
|
var field3 = typeof (CBOTest).GetField ("s1");
|
|
var s1 = field3.GetValue (instance);
|
|
Assert.AreEqual (s1, "abcd", "s1");
|
|
|
|
var field4 = typeof (CBOTest).GetField ("s2");
|
|
var s2 = field4.GetValue (instance);
|
|
Assert.AreEqual (s2, "hijkl", "s2");
|
|
}
|
|
|
|
[Test]
|
|
public void SetValueContextBoundObject ()
|
|
{
|
|
var instance = new CBOTest ();
|
|
|
|
var field1 = typeof (CBOTest).GetField ("d1");
|
|
field1.SetValue (instance, 90.3);
|
|
var d1 = field1.GetValue (instance);
|
|
Assert.AreEqual ((double)d1, 90.3, "d1");
|
|
|
|
var field2 = typeof (CBOTest).GetField ("d2");
|
|
field2.SetValue (instance, 1);
|
|
var d2 = field2.GetValue (instance);
|
|
Assert.AreEqual ((double)d2, 1, "d2");
|
|
|
|
var field3 = typeof (CBOTest).GetField ("s1");
|
|
field3.SetValue (instance, "//////");
|
|
var s1 = field3.GetValue (instance);
|
|
Assert.AreEqual (s1, "//////", "s1");
|
|
|
|
var field4 = typeof (CBOTest).GetField ("s2");
|
|
field4.SetValue (instance, "This is a string");
|
|
var s2 = field4.GetValue (instance);
|
|
Assert.AreEqual (s2, "This is a string", "s2");
|
|
|
|
}
|
|
|
|
class CBOTest : ContextBoundObject {
|
|
public double d1 = 14.0;
|
|
public double d2 = -20.0;
|
|
public string s1 = "abcd";
|
|
public string s2 = "hijkl";
|
|
}
|
|
|
|
|
|
public IntEnum PPP;
|
|
|
|
public class Foo<T>
|
|
{
|
|
/*
|
|
The whole point of this field is to make sure we don't create the vtable layout
|
|
when loading the value of constants for Foo<>. See bug #594942.
|
|
|
|
*/
|
|
public T dummy;
|
|
public static int field;
|
|
public const int constant = 10;
|
|
public const string sconstant = "waa";
|
|
public const IntEnum econstant = IntEnum.Third;
|
|
}
|
|
|
|
public enum IntEnum {
|
|
First = 1,
|
|
Second = 2,
|
|
Third = 3
|
|
}
|
|
|
|
public enum LongEnum : long {
|
|
First = 1,
|
|
Second = 2,
|
|
Third = 3
|
|
}
|
|
|
|
public const int int_field = 5;
|
|
public const long long_field = Int64.MaxValue;
|
|
public const IntEnum int_enum_field = IntEnum.Second;
|
|
public const LongEnum long_enum_field = LongEnum.Second;
|
|
public const string string_field = "Hello";
|
|
public const FieldInfoTest object_field = null;
|
|
public int non_const_field;
|
|
|
|
}
|
|
|
|
// We do not refernece the field, that is expected
|
|
#pragma warning disable 169
|
|
// Helper classes
|
|
class RefOnlyFieldClass
|
|
{
|
|
// Helper property
|
|
static int RefOnlyField;
|
|
}
|
|
#pragma warning restore 169
|
|
|
|
class NonPublicFieldClass
|
|
{
|
|
protected int protectedField;
|
|
|
|
public void Dummy ()
|
|
{
|
|
protectedField = 1;
|
|
}
|
|
}
|
|
|
|
public class FieldInfoTest<T>
|
|
{
|
|
public T TestField;
|
|
}
|
|
}
|