public void ExactBindingFlags()
{
var flags = BindingFlags.ExactBinding;
var reflector = new BindingReflector().ExactBinding;
HasFlags(reflector, flags);
}
public void DefaultFlags()
{
var flags = BindingFlags.Default;
var reflector = new BindingReflector();
HasFlags(reflector, flags);
}
public void FlattenHierarchyFlags()
{
var flags = BindingFlags.FlattenHierarchy;
var reflector = new BindingReflector().FlattenHierarchy;
HasFlags(reflector, flags);
}
public void DeclaredOnlyFlags()
{
var flags = BindingFlags.DeclaredOnly;
var reflector = new BindingReflector().DeclaredOnly;
HasFlags(reflector, flags);
}
public void InvokeMethodFlags()
{
var flags = BindingFlags.InvokeMethod;
var reflector = new BindingReflector().InvokeMethod;
HasFlags(reflector, flags);
}
public void SuppressChangeTypeFlags()
{
var flags = BindingFlags.SuppressChangeType;
var reflector = new BindingReflector().SuppressChangeType;
HasFlags(reflector, flags);
}
public void OptionalParamBindingFlags()
{
var flags = BindingFlags.OptionalParamBinding;
var reflector = new BindingReflector().OptionalParamBinding;
HasFlags(reflector, flags);
}
public void SetFieldFlags()
{
var flags = BindingFlags.SetField;
var reflector = new BindingReflector().SetField;
HasFlags(reflector, flags);
}
public void StaticFlags()
{
var flags = BindingFlags.Static;
var reflector = new BindingReflector().Static;
HasFlags(reflector, flags);
}
public void SetPropertyFlags()
{
var flags = BindingFlags.SetProperty;
var reflector = new BindingReflector().SetProperty;
HasFlags(reflector, flags);
}
public void CreateInstanceFlags()
{
var reflector = new BindingReflector().CreateInstance;
Assert.IsTrue(reflector.HasCreateInstance);
HasFlags(reflector, BindingFlags.CreateInstance);
}
public void PutRefDispPropertyFlags()
{
var flags = BindingFlags.PutRefDispProperty;
var reflector = new BindingReflector().PutRefDispProperty;
HasFlags(reflector, flags);
}
public void NonPublicFlags()
{
var flags = BindingFlags.NonPublic;
var reflector = new BindingReflector().NonPublic;
HasFlags(reflector, flags);
}
public void IgnoreReturnFlags()
{
var flags = BindingFlags.IgnoreReturn;
var reflector = new BindingReflector().IgnoreReturn;
HasFlags(reflector, flags);
}
public void IgnoreCaseFlags()
{
var flags = BindingFlags.IgnoreCase;
var reflector = new BindingReflector().IgnoreCase;
HasFlags(reflector, flags);
}
public void HasFlags(BindingReflector reflector, BindingFlags flags)
{
Assert.AreEqual(flags, reflector.Flags);
reflector = reflector.Public.NonPublic.Static;
Assert.AreNotEqual(flags, reflector.Flags);
}
public void CreateInstance1()
{
var obj = new BindingReflector();
Assert.IsTrue(obj.HasDefault);
Assert.IsTrue(obj.InstanceObject == null);
Assert.IsTrue(obj.Type == null);
Assert.IsTrue(obj.Flags == BindingFlags.Default);
}
public void FlagsOff()
{
var obj = new BindingReflector();
var publicNonPublic = obj.Public.NonPublic;
Assert.IsTrue(publicNonPublic.HasPublic);
Assert.IsTrue(publicNonPublic.HasNonPublic);
publicNonPublic = publicNonPublic.FlagsOff(BindingFlags.Public);
Assert.IsFalse(publicNonPublic.HasPublic);
Assert.IsTrue(publicNonPublic.HasNonPublic);
}
public void Bind2()
{
var reflector = CreateReflector();
var binding = new BindingReflector().Public.NonPublic.Static;
var acceser = reflector.Bind(binding);
Assert.IsTrue(acceser.BindingReflector.HasPublic);
Assert.IsTrue(acceser.BindingReflector.HasNonPublic);
Assert.IsTrue(acceser.BindingReflector.HasStatic);
Assert.AreEqual(binding.InstanceObject, acceser.InstanceObject);
Assert.AreEqual(typeof(ConstructorTarget), acceser.Type);
}
public void CreateInstance2()
{
var testobj = new object();
var testBinding = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var testType = typeof(object);
var obj = new BindingReflector(testBinding, testType, testobj);
Assert.IsTrue(obj.HasInstance);
Assert.IsTrue(obj.HasPublic);
Assert.IsTrue(obj.HasNonPublic);
Assert.AreEqual(testType, obj.Type);
Assert.AreEqual(testobj, obj.InstanceObject);
Assert.AreEqual(testBinding, obj.Flags);
}
public void GenerateAccessReflectorError()
{
var publicNonPublic = new BindingReflector().Public.NonPublic;
Assert.Throws <InvalidOperationException>(() => { publicNonPublic.GenerateAccessReflector(); });
}
private void AssertTypeAndObject <T>(BindingReflector reflector, T obj)
{
Assert.AreEqual(obj, reflector.InstanceObject);
Assert.AreEqual(typeof(T), reflector.Type);
}
