public void ImmediateFieldSerialization()
{
var field = new ImmediateField(PublicReferenceTypePublicFieldFieldsInfo);
ImmediateField deserializedField = SerializeAndDeserialize(field);
Assert.AreEqual(nameof(PublicReferenceTypeTestClass._publicField), deserializedField.Name);
Assert.AreEqual(typeof(PublicReferenceTypeTestClass), deserializedField.DeclaringType);
Assert.AreEqual(typeof(TestObject), deserializedField.FieldType);
Assert.AreEqual(PublicReferenceTypePublicFieldFieldsInfo, deserializedField.FieldInfo);
field = new ImmediateField(TestEnumField1FieldInfo);
deserializedField = SerializeAndDeserialize(field);
Assert.AreEqual(nameof(TestEnum.EnumValue1), deserializedField.Name);
Assert.AreEqual(typeof(TestEnum), deserializedField.DeclaringType);
Assert.AreEqual(typeof(TestEnum), deserializedField.FieldType);
Assert.AreEqual(TestEnumField1FieldInfo, deserializedField.FieldInfo);
field = new ImmediateField(TestEnumULongFieldValueFieldInfo);
deserializedField = SerializeAndDeserialize(field);
Assert.AreEqual(EnumValueFieldName, deserializedField.Name);
Assert.AreEqual(typeof(TestEnumULong), deserializedField.DeclaringType);
Assert.AreEqual(typeof(ulong), deserializedField.FieldType);
Assert.AreEqual(TestEnumULongFieldValueFieldInfo, deserializedField.FieldInfo);
}
public void ImmediateFieldSetValue_NestedTypes()
{
var publicNestedTypeTestObject = new PublicTestClass.PublicNestedClass {
_nestedTestValue = 1
};
var immediateField = new ImmediateField(PublicNestedPublicFieldFieldInfo);
immediateField.SetValue(publicNestedTypeTestObject, 12);
Assert.AreEqual(12, publicNestedTypeTestObject._nestedTestValue);
var internalNestedTypeTestObject = new PublicTestClass.InternalNestedClass {
_nestedTestValue = 2
};
immediateField = new ImmediateField(InternalNestedPublicFieldFieldInfo);
immediateField.SetValue(internalNestedTypeTestObject, 24);
Assert.AreEqual(24, internalNestedTypeTestObject._nestedTestValue);
var protectedNestedTypeTestObject = new ProtectedNestedClass {
_nestedTestValue = 3
};
immediateField = new ImmediateField(ProtectedNestedPublicFieldFieldInfo);
immediateField.SetValue(protectedNestedTypeTestObject, 48);
Assert.AreEqual(48, protectedNestedTypeTestObject._nestedTestValue);
var privateNestedTypeTestObject = new PrivateNestedClass {
_nestedTestValue = 4
};
immediateField = new ImmediateField(PrivateNestedPublicFieldFieldInfo);
immediateField.SetValue(privateNestedTypeTestObject, 96);
Assert.AreEqual(96, privateNestedTypeTestObject._nestedTestValue);
}
public void SetImmediateField_Field()
{
ImmediateField.SetValue(BenchmarkObject, ValueToSet);
ImmediateField2.SetValue(BenchmarkObject2, ValueToSet2);
ImmediateField3.SetValue(BenchmarkObject3, ValueToSet3);
ImmediateField4.SetValue(BenchmarkObject4, ValueToSet4);
}
public void ImmediateFieldGetValue_EnumThrows()
{
var immediateField = new ImmediateField(TestEnumFieldValueFieldInfo);
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.Throws <TargetException>(() => immediateField.GetValue(null));
}
public void ImmediateFieldSetValue_NullInstance()
{
var immediateField = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <TargetException>(() => immediateField.SetValue(null, null));
}
public void ImmediateFieldInfo()
{
var immediateField1 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.AreEqual(nameof(PublicValueTypeTestClass._publicField), immediateField1.Name);
Assert.AreEqual(typeof(PublicValueTypeTestClass), immediateField1.DeclaringType);
Assert.AreEqual(typeof(int), immediateField1.FieldType);
Assert.AreEqual(PublicValueTypePublicFieldFieldsInfo, immediateField1.FieldInfo);
var immediateField2 = new ImmediateField(PublicValueTypePublicField2FieldsInfo);
Assert.AreNotEqual(immediateField1.FieldInfo, immediateField2.FieldInfo);
var enumImmediateField = new ImmediateField(TestEnumField1FieldInfo);
Assert.AreEqual(nameof(TestEnum.EnumValue1), enumImmediateField.Name);
Assert.AreEqual(typeof(TestEnum), enumImmediateField.DeclaringType);
Assert.AreEqual(typeof(TestEnum), enumImmediateField.FieldType);
Assert.AreEqual(TestEnumField1FieldInfo, enumImmediateField.FieldInfo);
var currentEnumValueImmediateField = new ImmediateField(TestEnumULongFieldValueFieldInfo);
Assert.AreEqual(EnumValueFieldName, currentEnumValueImmediateField.Name);
Assert.AreEqual(typeof(TestEnumULong), currentEnumValueImmediateField.DeclaringType);
Assert.AreEqual(typeof(ulong), currentEnumValueImmediateField.FieldType);
Assert.AreEqual(TestEnumULongFieldValueFieldInfo, currentEnumValueImmediateField.FieldInfo);
}
public void ImmediateFieldGetValue_Enum()
{
// Simple TestEnum
const TestEnum testEnum1 = TestEnum.EnumValue2;
var immediateField = new ImmediateField(TestEnumFieldValueFieldInfo);
Assert.AreEqual((int)TestEnum.EnumValue2, immediateField.GetValue(testEnum1));
immediateField = new ImmediateField(TestEnumField2FieldInfo);
Assert.AreEqual(TestEnum.EnumValue2, immediateField.GetValue(null));
// TestEnum (inherit ulong)
const TestEnumULong testEnum2 = TestEnumULong.EnumValue1;
immediateField = new ImmediateField(TestEnumULongFieldValueFieldInfo);
Assert.AreEqual((ulong)TestEnumULong.EnumValue1, immediateField.GetValue(testEnum2));
immediateField = new ImmediateField(TestEnumULongField1FieldInfo);
Assert.AreEqual(TestEnumULong.EnumValue1, immediateField.GetValue(null));
// TestEnumFlags
const TestEnumFlags testEnum3 = TestEnumFlags.EnumValue1 | TestEnumFlags.EnumValue2;
immediateField = new ImmediateField(TestEnumFlagsFieldValueFieldInfo);
Assert.AreEqual((int)(TestEnumFlags.EnumValue1 | TestEnumFlags.EnumValue2), immediateField.GetValue(testEnum3));
immediateField = new ImmediateField(TestEnumFlagsField3FieldInfo);
Assert.AreEqual(TestEnumFlags.EnumValue3, immediateField.GetValue(null));
}
public void ImmediateFieldGetValue_NullInstance()
{
var immediateField = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
// ReSharper disable once AssignNullToNotNullAttribute
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Assert.Throws <TargetException>(() => immediateField.GetValue(null));
}
public void ImmediateFieldSetValue_Enum()
{
TestEnum testEnum = TestEnum.EnumValue2;
var immediateField = new ImmediateField(TestEnumFieldValueFieldInfo);
immediateField.SetValue(testEnum, TestEnum.EnumValue1);
Assert.AreEqual(TestEnum.EnumValue2, testEnum); // Enum internal value cannot be set
}
public void ImmediateFieldSetValue_Struct()
{
var testStruct = new TestStruct();
var immediateField = new ImmediateField(TestStructTestFieldFieldInfo);
immediateField.SetValue(testStruct, 45);
Assert.AreEqual(0, testStruct._testValue); // Not updated there (but on the shadow copy yes) since struct are immutable
// Limitation is the same with classic FieldInfo
}
public void ImmediateFieldToString()
{
var immediateField1 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.AreEqual(PublicValueTypePublicFieldFieldsInfo.ToString(), immediateField1.ToString());
var immediateField2 = new ImmediateField(PublicValueTypePublicField2FieldsInfo);
Assert.AreNotEqual(immediateField1.ToString(), immediateField2.ToString());
}
public void ImmediateFieldHashCode()
{
var immediateField1 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
var immediateField2 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.AreEqual(PublicValueTypePublicFieldFieldsInfo.GetHashCode(), immediateField1.GetHashCode());
Assert.AreEqual(immediateField1.GetHashCode(), immediateField2.GetHashCode());
var immediateField3 = new ImmediateField(PublicValueTypePublicField2FieldsInfo);
Assert.AreNotEqual(immediateField1.GetHashCode(), immediateField3.GetHashCode());
}
public void ImmediateFieldSetValue_WrongValue()
{
var immediateField1 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.Throws <InvalidCastException>(() => immediateField1.SetValue(new PublicValueTypeTestClass(), new TestObject()));
var immediateField2 = new ImmediateField(PublicReferenceTypePublicFieldFieldsInfo);
Assert.Throws <InvalidCastException>(() => immediateField2.SetValue(new PublicReferenceTypeTestClass(), 12));
var immediateField3 = new ImmediateField(PublicReferenceTypePublicFieldFieldsInfo);
Assert.Throws <InvalidCastException>(() => immediateField3.SetValue(new PublicReferenceTypeTestClass(), new SmallObject()));
}
public void ImmediateFieldGetValue_Constant()
{
var testObject = new PublicValueTypeTestClass();
// Static readonly
var immediateField = new ImmediateField(PublicValueTypeStaticReadonlyPublicFieldFieldsInfo);
Assert.AreEqual(112, immediateField.GetValue(testObject));
Assert.AreEqual(112, immediateField.GetValue(null));
// Constant
immediateField = new ImmediateField(PublicValueTypeConstPublicFieldFieldsInfo);
Assert.AreEqual(221, immediateField.GetValue(testObject));
Assert.AreEqual(221, immediateField.GetValue(null));
}
public void ImmediateFieldSetValue_Constant()
{
var testObject = new PublicValueTypeTestClass();
// Static readonly
var immediateField = new ImmediateField(PublicValueTypeStaticReadonlyPublicFieldFieldsInfo);
Assert.Throws <FieldAccessException>(() => immediateField.SetValue(testObject, 123456));
Assert.Throws <FieldAccessException>(() => immediateField.SetValue(null, 123456));
// Constant
immediateField = new ImmediateField(PublicValueTypeConstPublicFieldFieldsInfo);
Assert.Throws <FieldAccessException>(() => immediateField.SetValue(testObject, 123456));
Assert.Throws <FieldAccessException>(() => immediateField.SetValue(null, 123456));
}
public void ImmediateFieldEquality()
{
var immediateField1 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
var immediateField2 = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.IsTrue(immediateField1.Equals(immediateField1));
Assert.IsTrue(immediateField1.Equals(immediateField2));
Assert.IsTrue(immediateField1.Equals((object)immediateField2));
Assert.IsFalse(immediateField1.Equals(null));
var immediateField3 = new ImmediateField(PublicValueTypePublicField2FieldsInfo);
Assert.IsFalse(immediateField1.Equals(immediateField3));
Assert.IsFalse(immediateField1.Equals((object)immediateField3));
}
public void GetImmediateField()
{
Type testType = typeof(PublicValueTypeTestClass);
ImmediateField field = testType.GetImmediateField(nameof(PublicValueTypeTestClass._publicField));
Assert.IsNotNull(field);
Assert.AreEqual(PublicValueTypePublicFieldFieldsInfo, field.FieldInfo);
field = testType.GetImmediateField("_privateField", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.IsNotNull(field);
Assert.AreEqual(PublicValueTypePrivateFieldFieldsInfo, field.FieldInfo);
field = testType.GetImmediateField("_notExists");
Assert.IsNull(field);
}
public void ImmediateFieldGetValue_Static()
{
var testObject1 = new TestObject {
TestValue = 1
};
var testObject2 = new TestObject {
TestValue = 2
};
// Value type
PublicValueTypeTestClass._publicStaticField = 12;
var immediateField = new ImmediateField(PublicValueTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(12, immediateField.GetValue(null));
InternalValueTypeTestClass._publicStaticField = 24;
immediateField = new ImmediateField(InternalValueTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(24, immediateField.GetValue(null));
// Reference type
PublicReferenceTypeTestClass._publicStaticField = testObject1;
immediateField = new ImmediateField(PublicReferenceTypeStaticPublicFieldFieldsInfo);
Assert.AreSame(testObject1, immediateField.GetValue(null));
InternalReferenceTypeTestClass._publicStaticField = testObject2;
immediateField = new ImmediateField(InternalReferenceTypeStaticPublicFieldFieldsInfo);
Assert.AreSame(testObject2, immediateField.GetValue(null));
// Object type
PublicObjectTypeTestClass._publicStaticField = 48;
immediateField = new ImmediateField(PublicObjectTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(48, immediateField.GetValue(null));
InternalObjectTypeTestClass._publicStaticField = 96;
immediateField = new ImmediateField(InternalObjectTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(96, immediateField.GetValue(null));
PublicObjectTypeTestClass._publicStaticField = testObject1;
immediateField = new ImmediateField(PublicObjectTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(testObject1, immediateField.GetValue(null));
InternalObjectTypeTestClass._publicStaticField = testObject2;
immediateField = new ImmediateField(InternalObjectTypeStaticPublicFieldFieldsInfo);
Assert.AreEqual(testObject2, immediateField.GetValue(null));
}
public void GetField()
{
var immediateFields = new ImmediateFields(SmallObjectFieldInfos);
var expectedField = new ImmediateField(SmallObjectTestField1FieldInfo);
Assert.AreEqual(expectedField, immediateFields[nameof(SmallObject._testField1)]);
Assert.AreEqual(expectedField, immediateFields.GetField(nameof(SmallObject._testField1)));
Assert.IsNull(immediateFields["NotExists"]);
Assert.IsNull(immediateFields.GetField("NotExists"));
// ReSharper disable InconsistentNaming
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => { var _ = immediateFields[null]; });
Assert.Throws <ArgumentNullException>(() => { var _ = immediateFields.GetField(null); });
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore InconsistentNaming
}
public void ImmediateFieldGetValue([NotNull] object target, [NotNull] FieldInfo field, [CanBeNull] object expectedValue)
{
var immediateField = new ImmediateField(field);
object gotValue = immediateField.GetValue(target);
if (expectedValue is null)
{
Assert.IsNull(gotValue);
}
else if (expectedValue.GetType().IsValueType)
{
Assert.AreEqual(expectedValue, gotValue);
}
else
{
Assert.AreSame(expectedValue, gotValue);
}
}
public void ImmediateFieldSetValue_Static()
{
var testObject = new TestObject {
TestValue = 1
};
// Value type
var immediateProperty = new ImmediateField(PublicValueTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, 12);
Assert.AreEqual(12, PublicValueTypeTestClass._publicStaticField);
immediateProperty = new ImmediateField(InternalValueTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, 24);
Assert.AreEqual(24, InternalValueTypeTestClass._publicStaticField);
// Reference type
immediateProperty = new ImmediateField(PublicReferenceTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, testObject);
Assert.AreSame(testObject, PublicReferenceTypeTestClass._publicStaticField);
immediateProperty = new ImmediateField(InternalReferenceTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, testObject);
Assert.AreSame(testObject, InternalReferenceTypeTestClass._publicStaticField);
// Object type
immediateProperty = new ImmediateField(PublicObjectTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, 48);
Assert.AreEqual(48, PublicObjectTypeTestClass._publicStaticField);
immediateProperty = new ImmediateField(InternalObjectTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, 96);
Assert.AreEqual(96, InternalObjectTypeTestClass._publicStaticField);
immediateProperty = new ImmediateField(PublicObjectTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, testObject);
Assert.AreSame(testObject, PublicObjectTypeTestClass._publicStaticField);
immediateProperty = new ImmediateField(InternalObjectTypeStaticPublicFieldFieldsInfo);
immediateProperty.SetValue(null, testObject);
Assert.AreSame(testObject, InternalObjectTypeTestClass._publicStaticField);
}
public void ImmediateFieldSetValue_ValueType()
{
// Value type / Public
var publicValueTypeTestObject = new PublicValueTypeTestClass();
var immediateField = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
immediateField.SetValue(publicValueTypeTestObject, 12);
Assert.AreEqual(12, publicValueTypeTestObject._publicField);
immediateField = new ImmediateField(PublicValueTypeInternalFieldFieldsInfo);
immediateField.SetValue(publicValueTypeTestObject, 24);
Assert.AreEqual(24, publicValueTypeTestObject._internalField);
immediateField = new ImmediateField(PublicValueTypeProtectedFieldFieldsInfo);
immediateField.SetValue(publicValueTypeTestObject, 48);
Assert.AreEqual(48, publicValueTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(PublicValueTypePrivateFieldFieldsInfo);
immediateField.SetValue(publicValueTypeTestObject, 96);
Assert.AreEqual(96, publicValueTypeTestObject.GetPrivateFieldValue());
// Value type / Internal
var internalValueTypeTestObject = new InternalValueTypeTestClass();
immediateField = new ImmediateField(InternalValueTypePublicFieldFieldsInfo);
immediateField.SetValue(internalValueTypeTestObject, 192);
Assert.AreEqual(192, internalValueTypeTestObject._publicField);
immediateField = new ImmediateField(InternalValueTypeInternalFieldFieldsInfo);
immediateField.SetValue(internalValueTypeTestObject, 384);
Assert.AreEqual(384, internalValueTypeTestObject._internalField);
immediateField = new ImmediateField(InternalValueTypeProtectedFieldFieldsInfo);
immediateField.SetValue(internalValueTypeTestObject, 728);
Assert.AreEqual(728, internalValueTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(InternalValueTypePrivateFieldFieldsInfo);
immediateField.SetValue(internalValueTypeTestObject, 1536);
Assert.AreEqual(1536, internalValueTypeTestObject.GetPrivateFieldValue());
}
public void ImmediateFieldSetValue_ObjectType()
{
var testObject1 = new TestObject {
TestValue = 1
};
var testObject2 = new TestObject {
TestValue = 2
};
var testObject3 = new TestObject {
TestValue = 3
};
var testObject4 = new TestObject {
TestValue = 4
};
var testObject5 = new TestObject {
TestValue = 5
};
var testObject6 = new TestObject {
TestValue = 6
};
var testObject7 = new TestObject {
TestValue = 7
};
var testObject8 = new TestObject {
TestValue = 8
};
// Object type / Public
var publicObjectTypeTestObject = new PublicObjectTypeTestClass();
var immediateField = new ImmediateField(PublicObjectTypePublicFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, 1);
Assert.AreEqual(1, publicObjectTypeTestObject._publicField);
immediateField = new ImmediateField(PublicObjectTypeInternalFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, 2);
Assert.AreEqual(2, publicObjectTypeTestObject._internalField);
immediateField = new ImmediateField(PublicObjectTypeProtectedFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, 3);
Assert.AreEqual(3, publicObjectTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(PublicObjectTypePrivateFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, 4);
Assert.AreEqual(4, publicObjectTypeTestObject.GetPrivateFieldValue());
immediateField = new ImmediateField(PublicObjectTypePublicFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, testObject1);
Assert.AreSame(testObject1, publicObjectTypeTestObject._publicField);
immediateField = new ImmediateField(PublicObjectTypeInternalFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, testObject2);
Assert.AreSame(testObject2, publicObjectTypeTestObject._internalField);
immediateField = new ImmediateField(PublicObjectTypeProtectedFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, testObject3);
Assert.AreSame(testObject3, publicObjectTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(PublicObjectTypePrivateFieldFieldsInfo);
immediateField.SetValue(publicObjectTypeTestObject, testObject4);
Assert.AreSame(testObject4, publicObjectTypeTestObject.GetPrivateFieldValue());
// Object type / Internal
var internalObjectTypeTestObject = new InternalObjectTypeTestClass();
immediateField = new ImmediateField(InternalObjectTypePublicFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, 1);
Assert.AreEqual(1, internalObjectTypeTestObject._publicField);
immediateField = new ImmediateField(InternalObjectTypeInternalFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, 2);
Assert.AreEqual(2, internalObjectTypeTestObject._internalField);
immediateField = new ImmediateField(InternalObjectTypeProtectedFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, 3);
Assert.AreEqual(3, internalObjectTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(InternalObjectTypePrivateFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, 4);
Assert.AreEqual(4, internalObjectTypeTestObject.GetPrivateFieldValue());
immediateField = new ImmediateField(InternalObjectTypePublicFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, testObject5);
Assert.AreSame(testObject5, internalObjectTypeTestObject._publicField);
immediateField = new ImmediateField(InternalObjectTypeInternalFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, testObject6);
Assert.AreSame(testObject6, internalObjectTypeTestObject._internalField);
immediateField = new ImmediateField(InternalObjectTypeProtectedFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, testObject7);
Assert.AreSame(testObject7, internalObjectTypeTestObject.GetProtectedFieldValue());
immediateField = new ImmediateField(InternalObjectTypePrivateFieldFieldsInfo);
immediateField.SetValue(internalObjectTypeTestObject, testObject8);
Assert.AreSame(testObject8, internalObjectTypeTestObject.GetPrivateFieldValue());
}
public int GetImmediateField_Field()
{
return((int)ImmediateField.GetValue(BenchmarkObject));
}
public void SetImmediateField_Field()
{
ImmediateField.SetValue(BenchmarkObject, ValueToSet);
}
public string GetImmediateField_Field()
{
return($"{(int)ImmediateField.GetValue(BenchmarkObject)}{(float)ImmediateField2.GetValue(BenchmarkObject2)}{(string)ImmediateField3.GetValue(BenchmarkObject3)}{(uint)ImmediateField4.GetValue(BenchmarkObject4)}");
}
public void ImmediateFieldSetValue_WrongInstance()
{
var immediateField = new ImmediateField(PublicValueTypePublicFieldFieldsInfo);
Assert.Throws <InvalidCastException>(() => immediateField.SetValue(new PublicReferenceTypeTestClass(), null));
}
