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 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); }
/// <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 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 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); }