List <Tuple <MethodInfo, object> > SlurpAllNullEventHandlers(bool forceNoNull)
{
List <Tuple <MethodInfo, object> > retVal = new List <Tuple <MethodInfo, object> >();
if (forceNoNull)
{
return(retVal);
}
// Adding NULL static methods (if any)
if (_staticEvents.ContainsKey(""))
{
foreach (Tuple <MethodInfo, object> idx in _staticEvents[""])
{
retVal.Add(idx);
}
}
// Adding NULL instance methods (if any)
if (InstanceMethod.ContainsKey(""))
{
foreach (Tuple <MethodInfo, object> idx in InstanceMethod[""])
{
retVal.Add(idx);
}
}
return(retVal);
}
private void Awake()
{
Test = 10;
string hotfixMonoBehaviourFullName = "HotFix_Project." + m_HotfixMonoBehaviourName;
if (HotfixManager.Instance.ILRuntimeMode)
{
IType type = HotfixManager.Instance.Appdomain.LoadedTypes[hotfixMonoBehaviourFullName];
HotfixInstance = ((ILType)type).Instantiate();
m_Start = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Start", 0);
m_Update = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Update", 0);
m_Test = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Test", 1);
HotfixManager.Instance.Appdomain.Invoke(hotfixMonoBehaviourFullName, "Awake", HotfixInstance, this);
}
else
{
HotfixInstance = HotfixManager.Instance.HotfixAssembly.CreateInstance(hotfixMonoBehaviourFullName);
InstanceMethod awake = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Awake", new Type[] { typeof(MainMonoBehaviour) });
m_Start = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Start", null);
m_Update = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Update", null);
m_Test = new InstanceMethod(HotfixInstance, hotfixMonoBehaviourFullName, "Test", new Type[] { typeof(int) });
awake?.Invoke(this);
}
m_Test.Invoke(5);
}
// TODO: Try to remove or make internal somehow...?
public void RemoveListener(object context)
{
List <string> toRemoKeys = new List <string>();
// Removing all event handler with the given context (object instance)
foreach (string idx in InstanceMethod.Keys)
{
List <Tuple <MethodInfo, object> > idxCur = InstanceMethod[idx];
List <Tuple <MethodInfo, object> > toRemove =
new List <Tuple <MethodInfo, object> >();
foreach (Tuple <MethodInfo, object> idxObj in idxCur)
{
if (idxObj.Item2 == context)
{
toRemove.Add(idxObj);
}
}
foreach (Tuple <MethodInfo, object> idxObj in toRemove)
{
idxCur.Remove(idxObj);
if (idxCur.Count == 0)
{
toRemoKeys.Add(idx);
}
}
}
foreach (string idx in toRemoKeys)
{
InstanceMethod.Remove(idx);
}
}
public void SlamInstance()
{
InstanceMethod original = new InstanceMethod();
Log.Output(@" Current Value of IntanceMethod.Add(1,1) = " + original.Add(1, 1).ToString());
Injector.SlamClass(typeof(InstanceMethod), typeof(InstanceMethod_NewMath));
Log.Output(" New Value of IntanceMethod.Add(1,1) = " + original.Add(1, 1).ToString());
}
public void SutIsEquatable()
{
// Arrange
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
// Act
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Assert
Assert.IsAssignableFrom <IEquatable <InstanceMethod> >(sut);
}
public void SutIsMethod()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
// Exercise system
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Verify outcome
Assert.IsAssignableFrom<IMethod>(sut);
// Teardown
}
public void SutDoesNotEqualSomeOtherObject()
{
// Arrange
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Act
var result = sut.Equals(new object());
// Assert
Assert.False(result);
}
public void SutIsEquatable()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
// Exercise system
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Verify outcome
Assert.IsAssignableFrom <IEquatable <InstanceMethod> >(sut);
// Teardown
}
public void MethodIsCorrect(Type type)
{
// Arrange
var expectedMethod = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(expectedMethod, dummyOwner);
// Act
MethodInfo result = sut.Method;
// Assert
Assert.Equal(expectedMethod, result);
}
public void OwnerIsCorrect()
{
// Arrange
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var expectedOwner = new object();
var sut = new InstanceMethod(dummyMethod, expectedOwner);
// Act
var result = sut.Owner;
// Assert
Assert.Equal(expectedOwner, result);
}
public void MethodIsCorrect(Type type)
{
// Fixture setup
var expectedMethod = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(expectedMethod, dummyOwner);
// Exercise system
MethodInfo result = sut.Method;
// Verify outcome
Assert.Equal(expectedMethod, result);
// Teardown
}
public void OwnerIsCorrect()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var expectedOwner = new object();
var sut = new InstanceMethod(dummyMethod, expectedOwner);
// Exercise system
var result = sut.Owner;
// Verify outcome
Assert.Equal(expectedOwner, result);
// Teardown
}
public void InvokeParameterlessMethodReturnsCorrectResult(object owner)
{
// Arrange
var method = owner.GetType().GetMethod("GetHashCode", Type.EmptyTypes);
var sut = new InstanceMethod(method, owner);
// Act
var result = sut.Invoke(Enumerable.Empty <object>());
// Assert
var expected = owner.GetHashCode();
Assert.Equal(expected, result);
}
public void OwnerIsCorrect()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var expectedOwner = new object();
var sut = new InstanceMethod(dummyMethod, expectedOwner);
// Exercise system
var result = sut.Owner;
// Verify outcome
Assert.Equal(expectedOwner, result);
// Teardown
}
public void MethodIsCorrect(Type type)
{
// Fixture setup
var expectedMethod = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(expectedMethod, dummyOwner);
// Exercise system
MethodInfo result = sut.Method;
// Verify outcome
Assert.Equal(expectedMethod, result);
// Teardown
}
public void InvokeParameterlessMethodReturnsCorrectResult(object owner)
{
// Fixture setup
var method = owner.GetType().GetMethod("GetHashCode", Type.EmptyTypes);
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Invoke(Enumerable.Empty <object>());
// Verify outcome
var expected = owner.GetHashCode();
Assert.Equal(expected, result);
// Teardown
}
public void SutDoesNotEqualSomeOtherObject()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Exercise system
var result = sut.Equals(new object());
// Verify outcome
Assert.False(result);
// Teardown
}
public void GetHashCodeReturnsCorrectResult()
{
// Arrange
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
// Act
var result = sut.GetHashCode();
// Assert
var expectedHasCode = method.GetHashCode() ^ owner.GetHashCode();
Assert.Equal(expectedHasCode, result);
}
public void InvokeMethodWithParametersReturnsCorrectResult(int x, int y)
{
// Arrange
var owner = Comparer <int> .Default;
var method = owner.GetType().GetMethod("Compare");
var sut = new InstanceMethod(method, owner);
// Act
var result = sut.Invoke(new object[] { x, y });
// Assert
var expected = owner.Compare(x, y);
Assert.Equal(expected, result);
}
public void SutEqualsOtherSutWithSameValues()
{
// Arrange
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
var other = new InstanceMethod(method, owner);
// Act
var result = sut.Equals(other);
// Assert
Assert.True(result);
}
public void SutEqualsOtherSutWithSameValues()
{
// Fixture setup
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
var other = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void GetHashCodeReturnsCorrectResult()
{
// Fixture setup
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.GetHashCode();
// Verify outcome
var expectedHasCode = method.GetHashCode() ^ owner.GetHashCode();
Assert.Equal(expectedHasCode, result);
// Teardown
}
public void InvokeMethodWithParametersReturnsCorrectResult(int x, int y)
{
// Fixture setup
var owner = Comparer <int> .Default;
var method = owner.GetType().GetMethod("Compare");
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Invoke(new object[] { x, y });
// Verify outcome
var expected = owner.Compare(x, y);
Assert.Equal(expected, result);
// Teardown
}
// TODO: WTF ...?
/**
* Returns true if Active Event is an override of an existing active event
*/
public bool IsOverrideSystem(string key)
{
bool retVal = _eventMappers.ContainsKey(key);
if (retVal)
{
retVal = InstanceMethod.ContainsKey(key);
if (!retVal)
{
retVal = _staticEvents.ContainsKey(key);
}
}
return(retVal);
}
public void ParametersReturnsCorrectResult(Type type, int index)
{
// Arrange
var method = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).ElementAt(index);
var expectedParameters = method.GetParameters();
var dummyOwner = new object();
var sut = new InstanceMethod(method, dummyOwner);
// Act
var result = sut.Parameters;
// Assert
Assert.True(expectedParameters.SequenceEqual(result));
}
public void SutDoesNotEqualOtherSutWithDifferentMethod()
{
// Arrange
var method1 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(method1, dummyOwner);
var method2 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).Skip(1).First();
object other = new InstanceMethod(method2, dummyOwner);
// Act
var result = sut.Equals(other);
// Assert
Assert.False(result);
}
public void ParametersReturnsCorrectResult(Type type, int index)
{
// Fixture setup
var method = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).ElementAt(index);
var expectedParameters = method.GetParameters();
var dummyOwner = new object();
var sut = new InstanceMethod(method, dummyOwner);
// Exercise system
var result = sut.Parameters;
// Verify outcome
Assert.True(expectedParameters.SequenceEqual(result));
// Teardown
}
public void SutDoesNotEqualOtherSutWithDifferentOwner()
{
// Arrange
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner1 = new object();
var sut = new InstanceMethod(dummyMethod, owner1);
var owner2 = new object();
var other = new InstanceMethod(dummyMethod, owner2);
// Act
var result = sut.Equals(other);
// Assert
Assert.False(result);
}
public void CreateExtendedCommandWithInstanceAsyncMethodReturnsMethodInvokeCommand()
{
var sut = new SutAlias();
var methodInfo = typeof(GuardClauseExtensionsTests).GetMethod(
nameof(this.InstanceCommandHelperMethodAsync),
BindingFlags.Instance | BindingFlags.NonPublic);
var method = new InstanceMethod(methodInfo, this);
var command = CreateWrappedMethodInvokeCommand(
method,
new IndexedReplacement <object>(0));
var actual = sut.CreateExtendedCommand(new Mock <ISpecimenBuilder>().Object, command);
Assert.IsType <AsyncMethodInvokeCommand>(
(actual as ReflectionExceptionUnwrappingCommand)?.Command);
}
public void SutDoesNotEqualOtherSutWithDifferentOwner()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner1 = new object();
var sut = new InstanceMethod(dummyMethod, owner1);
var owner2 = new object();
var other = new InstanceMethod(dummyMethod, owner2);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public void SutDoesNotEqualOtherSutWithDifferentMethod()
{
// Fixture setup
var method1 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(method1, dummyOwner);
var method2 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).Skip(1).First();
object other = new InstanceMethod(method2, dummyOwner);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
/// <summary>
/// Verifies that a method has appripriate Guard Clauses in place.
/// </summary>
/// <param name="methodInfo">The method.</param>
/// <remarks>
/// <para>
/// Exactly which Guard Clauses are verified is defined by
/// <see cref="BehaviorExpectation" />.
/// </para>
/// </remarks>
public override void Verify(MethodInfo methodInfo)
{
if (methodInfo == null)
{
throw new ArgumentNullException("methodInfo");
}
if (methodInfo.IsEqualsMethod())
{
return;
}
var owner = this.Builder.CreateAnonymous(methodInfo.ReflectedType);
var method = new InstanceMethod(methodInfo, owner);
this.Verify(method);
}
/// <summary>
/// Verifies that a method has appripriate Guard Clauses in place.
/// </summary>
/// <param name="methodInfo">The method.</param>
/// <remarks>
/// <para>
/// Exactly which Guard Clauses are verified is defined by
/// <see cref="BehaviorExpectation" />.
/// </para>
/// </remarks>
public override void Verify(MethodInfo methodInfo)
{
if (methodInfo == null)
{
throw new ArgumentNullException("methodInfo");
}
if (methodInfo.IsEqualsMethod())
{
return;
}
var owner = this.Builder.CreateAnonymous(methodInfo.ReflectedType);
var method = new InstanceMethod(methodInfo, owner);
var isReturnValueIterator =
typeof(System.Collections.IEnumerable).IsAssignableFrom(methodInfo.ReturnType) ||
typeof(System.Collections.IEnumerator).IsAssignableFrom(methodInfo.ReturnType);
this.Verify(method, isReturnValueIterator);
}
public void SutEqualsOtherSutWithSameValues()
{
// Fixture setup
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
var other = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void GetHashCodeReturnsCorrectResult()
{
// Fixture setup
var method = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner = new object();
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.GetHashCode();
// Verify outcome
var expectedHasCode = method.GetHashCode() ^ owner.GetHashCode();
Assert.Equal(expectedHasCode, result);
// Teardown
}
public void ParametersReturnsCorrectResult(Type type, int index)
{
// Fixture setup
var method = type.GetMethods(BindingFlags.Public | BindingFlags.Instance).ElementAt(index);
var expectedParameters = method.GetParameters();
var dummyOwner = new object();
var sut = new InstanceMethod(method, dummyOwner);
// Exercise system
var result = sut.Parameters;
// Verify outcome
Assert.True(expectedParameters.SequenceEqual(result));
// Teardown
}
/// <summary>
/// Verifies that a method has appripriate Guard Clauses in place.
/// </summary>
/// <param name="methodInfo">The method.</param>
/// <remarks>
/// <para>
/// Exactly which Guard Clauses are verified is defined by
/// <see cref="BehaviorExpectation" />.
/// </para>
/// </remarks>
public override void Verify(MethodInfo methodInfo)
{
if (methodInfo == null)
throw new ArgumentNullException("methodInfo");
if (methodInfo.IsEqualsMethod())
return;
var owner = this.Builder.CreateAnonymous(methodInfo.ReflectedType);
var method = new InstanceMethod(methodInfo, owner);
var isReturnValueIterator =
typeof(System.Collections.IEnumerable).IsAssignableFrom(methodInfo.ReturnType) ||
typeof(System.Collections.IEnumerator).IsAssignableFrom(methodInfo.ReturnType);
this.Verify(method, isReturnValueIterator);
}
public static bool TryGetValue(object obj, string propertyName, out object value, out Type type)
{
value = null;
type = typeof(object);
if (obj is IDynamicObject)
return ((IDynamicObject) obj).TryGetValue(propertyName, out value, out type);
Type targetType = obj.GetType();
MemberInfo[] members = targetType.GetMember(propertyName);
if (members.Length == 0)
{
PropertyInfo indexerPropInfo = targetType.GetProperty("Item", new[] { typeof(string) });
if (indexerPropInfo != null)
{
value = indexerPropInfo.GetValue(obj, new object[] { propertyName });
type = (value != null && indexerPropInfo.PropertyType == typeof(object)) ? value.GetType() : typeof(object);
return true;
}
return false;
}
if (members.Length >= 1 && members[0] is MethodInfo)
{
value = new InstanceMethod(targetType, propertyName, obj);
type = typeof(InstanceMethod);
return true;
}
MemberInfo member = members[0];
if (members.Length > 1) // CoolStorage, ActiveRecord and Dynamic Proxy frameworks sometimes return > 1 member
{
foreach (MemberInfo mi in members)
if (mi.DeclaringType == obj.GetType())
member = mi;
}
if (member is FieldInfo)
{
value = ((FieldInfo)member).GetValue(obj);
type = ((FieldInfo)member).FieldType;
return true;
}
if (member is PropertyInfo)
{
value = ((PropertyInfo)member).GetValue(obj, null);
type = ((PropertyInfo)member).PropertyType;
return true;
}
return false;
}
public void InvokeParameterlessMethodReturnsCorrectResult(object owner)
{
// Fixture setup
var method = owner.GetType().GetMethod("GetHashCode");
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Invoke(Enumerable.Empty<object>());
// Verify outcome
var expected = owner.GetHashCode();
Assert.Equal(expected, result);
// Teardown
}
public void SutDoesNotEqualSomeOtherObject()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(dummyMethod, dummyOwner);
// Exercise system
var result = sut.Equals(new object());
// Verify outcome
Assert.False(result);
// Teardown
}
public void InvokeMethodWithParametersReturnsCorrectResult(int x, int y)
{
// Fixture setup
var owner = Comparer<int>.Default;
var method = owner.GetType().GetMethod("Compare");
var sut = new InstanceMethod(method, owner);
// Exercise system
var result = sut.Invoke(new object[] { x, y });
// Verify outcome
var expected = owner.Compare(x, y);
Assert.Equal(expected, result);
// Teardown
}
public void SutDoesNotEqualOtherSutWithDifferentMethod()
{
// Fixture setup
var method1 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var dummyOwner = new object();
var sut = new InstanceMethod(method1, dummyOwner);
var method2 = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).Skip(1).First();
object other = new InstanceMethod(method2, dummyOwner);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public void SutDoesNotEqualOtherSutWithDifferentOwner()
{
// Fixture setup
var dummyMethod = typeof(object).GetMethods(BindingFlags.Public | BindingFlags.Instance).First();
var owner1 = new object();
var sut = new InstanceMethod(dummyMethod, owner1);
var owner2 = new object();
var other = new InstanceMethod(dummyMethod, owner2);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.False(result);
// Teardown
}
public static int test() {
var obj = new InstanceMethod();
return obj.instanceMethod();
}
/// <summary>
/// Verifies that a method has appripriate Guard Clauses in place.
/// </summary>
/// <param name="methodInfo">The method.</param>
/// <remarks>
/// <para>
/// Exactly which Guard Clauses are verified is defined by
/// <see cref="BehaviorExpectation" />.
/// </para>
/// </remarks>
public override void Verify(MethodInfo methodInfo)
{
if (methodInfo == null)
throw new ArgumentNullException("methodInfo");
if (methodInfo.IsEqualsMethod())
return;
var owner = this.Builder.CreateAnonymous(methodInfo.ReflectedType);
var method = new InstanceMethod(methodInfo, owner);
this.Verify(method);
}
