public void Trivial()
{
SR.MethodInfo mi = typeof(String).GetMethod("ToString", Type.EmptyTypes);
MethodReference mr1 = m_module.Import(mi);
Assert.IsTrue(MethodMatcher.Match(mr1, mr1));
}
private bool Test(HttpMethod expected, HttpMethod actual)
{
var sut = new MethodMatcher(expected);
return(sut.Matches(new HttpRequestMessage(actual,
"http://tempuri.org/home")));
}
public void Base()
{
SR.MethodInfo mi = typeof(String).GetMethod("ToString", Type.EmptyTypes);
MethodReference mr1a = m_module.Import(mi);
mi = typeof(String).GetMethod("ToString", new Type[] { typeof(IFormatProvider) });
MethodReference mr1b = m_module.Import(mi);
mi = typeof(Object).GetMethod("ToString");
MethodReference mr2 = m_module.Import(mi);
Assert.IsTrue(MethodMatcher.Match(mr1a, mr2));
Assert.IsFalse(MethodMatcher.Match(mr1b, mr2));
}
private void Scan(MethodMatcher matcher)
{
if (s_cache.TryGetValue(GetType(), out d_methods))
{
return;
}
d_methods = new Dictionary <Type, List <MethodInfo> >();
foreach (MethodInfo method in GetType().GetMethods(d_methodBinding))
{
if (!TypeIsA(method.ReturnType, d_returnType, (d_binding & BindingFlags.ExactReturnType) != 0))
{
continue;
}
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != d_parameterTypes.Length)
{
continue;
}
bool parametermatch = true;
for (int i = 0; i < parameters.Length; ++i)
{
if (!TypeIsA(parameters[i].ParameterType, d_parameterTypes[i], (i == 0 ? false : (d_binding & BindingFlags.ExactParameters) != 0)))
{
parametermatch = false;
break;
}
}
if (!parametermatch)
{
continue;
}
if (matcher != null && !matcher(method))
{
continue;
}
Add(method, parameters[0].ParameterType);
}
}
public void Should_return_null_if_not_match_anything()
{
// Arrange
var matcher = new MethodMatcher();
var request = new RpcRequest
{
DeclaringType = typeof(ISomeService).FullName,
MethodName = "MethodNotFound",
MemberType = MemberTypes.Method,
MethodSignature = matcher.GetMethodSignature(new DynamicMethod("MethodNotFound", typeof(void), null, true))
};
// Action
var method = matcher.Match <ISomeService>(request);
// Assert
Assert.IsNull(method);
}
public void Should_return_method_info_if_match()
{
// Arrange
var matcher = new MethodMatcher();
var request = new RpcRequest
{
DeclaringType = typeof(ISomeService).FullName,
MethodName = "TryParse",
MemberType = MemberTypes.Method,
MethodSignature = matcher.GetMethodSignature(typeof(ISomeService).GetMethod("TryParse"))
};
// Action
var method = matcher.Match<ISomeService>(request);
// Assert
Assert.IsNotNull(method);
}
public void Should_return_null_if_not_match_anything()
{
// Arrange
var matcher = new MethodMatcher();
var request = new RpcRequest
{
DeclaringType = typeof(ISomeService).FullName,
MethodName = "MethodNotFound",
MemberType = MemberTypes.Method,
MethodSignature = matcher.GetMethodSignature(new DynamicMethod("MethodNotFound", typeof(void), null, true))
};
// Action
var method = matcher.Match<ISomeService>(request);
// Assert
Assert.IsNull(method);
}
public void Should_return_method_info_if_match()
{
// Arrange
var matcher = new MethodMatcher();
var request = new RpcRequest
{
DeclaringType = typeof(ISomeService).FullName,
MethodName = "TryParse",
MemberType = MemberTypes.Method,
MethodSignature = matcher.GetMethodSignature(typeof(ISomeService).GetMethod("TryParse"))
};
// Action
var method = matcher.Match <ISomeService>(request);
// Assert
Assert.IsNotNull(method);
}
public bool MatchesIgnoringIsActive(Invocation invocation)
{
if (Receiver != invocation.Receiver)
{
return(false);
}
if (!MethodMatcher.Matches(invocation.Method))
{
return(false);
}
if (!ArgumentsMatcher.Matches(invocation))
{
return(false);
}
if (!ExtraMatchersMatch(invocation))
{
return(false);
}
return(true);
}
/// <summary>
/// Create a new MetaAnnotationMatchingPointcut for the given annotation type.
/// </summary>
/// <param name="classAnnotationType"> the annotation type to look for at the class level
/// (can be <code>null</code>) </param>
/// <param name="methodAnnotationType"> the annotation type to look for at the method level
/// (can be <code>null</code>) </param>
public MetaAnnotationMatchingPointcut(Type classAnnotationType, Type methodAnnotationType)
{
Assert.isTrue((classAnnotationType != null || methodAnnotationType != null), "Either Class annotation type or Method annotation type needs to be specified (or both)");
if (classAnnotationType != null)
{
this.classFilter = new AnnotationClassFilter(classAnnotationType);
}
else
{
this.classFilter = ClassFilter.TRUE;
}
if (methodAnnotationType != null)
{
this.methodMatcher = new MetaAnnotationMethodMatcher(methodAnnotationType);
}
else
{
this.methodMatcher = MethodMatcher.TRUE;
}
}
// Generic bases work.
// [Test]
public void GenericBase()
{
SR.MethodInfo mi = typeof(Int16).GetMethod("CompareTo", new Type[] { typeof(Int16) });
MethodReference mr1 = m_module.Import(mi);
Type[] types = typeof(Int16).GetInterfaces();
foreach (Type t in types)
{
if (t.IsGenericType)
{
mi = t.GetMethod("CompareTo");
if (mi != null)
{
MethodReference mr2 = m_module.Import(mi); // this throws
Console.WriteLine(mr1);
Console.WriteLine(mr2);
Assert.IsTrue(MethodMatcher.Match(mr1, mr2));
}
}
}
}
public virtual void Init()
{
var type = typeof(T);
var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance);
foreach (var m in methods)
{
foreach (var a in m.GetCustomAttributes())
{
if (!(a is LocalRouteAttribute lra))
{
continue;
}
var name = lra.Name ?? m.Name;
if (string.IsNullOrEmpty(name))
{
throw new InvalidOperationException(
$"local route name could not be resolved for method [{m.Name}]");
}
if (_matchersByName.ContainsKey(name))
{
throw new InvalidOperationException(
$"duplicate local route name [{name}] for method [{m.Name}]");
}
var mm = new MethodMatcher
{
LocalRoute = lra,
Method = m,
Matcher = new TemplateMatcher(TemplateParser.Parse(lra.PathPattern), null),
Name = name,
};
switch (lra)
{
case LocalListRouteAttribute _:
_listMatchers.Add(mm);
break;
case LocalReadRouteAttribute _:
_readMatchers.Add(mm);
break;
case LocalWriteRouteAttribute _:
_writeMatchers.Add(mm);
break;
case LocalDeleteRouteAttribute _:
_deleteMatchers.Add(mm);
break;
default:
throw new InvalidOperationException("unknown local route type");
}
_matchersByName.Add(name, mm);
}
}
}
public void MatchesFailingTest(MethodMetadata method, MethodMatcher matcher)
{
Assert.False(matcher.Matches(method));
}
public void DescribeTo(TextWriter writer)
{
if (MethodMatcher is MethodMatcher)
{
writer.Write(((MethodMatcher)MethodMatcher).ReturnType);
writer.Write(" ");
}
writer.Write(Receiver.MockName);
writer.Write(_methodSeparator);
if (MethodMatcher != null)
{
MethodMatcher.DescribeTo(writer);
}
ArgumentsMatcher.DescribeTo(writer);
if (_extraMatchers.Count > 0)
{
writer.Write(" Matching[");
for (int i = 0; i < _extraMatchers.Count; i++)
{
if (i != 0)
{
writer.Write(", ");
}
_extraMatchers[i].DescribeTo(writer);
}
writer.Write("]");
}
if (_actions.Count > 0)
{
writer.Write(" will ");
(_actions[0]).DescribeTo(writer);
for (int i = 1; i < _actions.Count; i++)
{
if (i != 0)
{
writer.Write(", ");
}
_actions[i].DescribeTo(writer);
}
}
if (IsValid)
{
writer.Write(" [EXPECTED: ");
writer.Write(_expectationDescription);
writer.Write(" CALLED: ");
writer.Write(_callCount);
writer.Write(" time");
if (_callCount != 1)
{
writer.Write("s");
}
writer.Write("]");
}
else
{
writer.Write(" [EXPECTATION NOT VALID because of runtime error or incomplete setup]");
}
if (!string.IsNullOrEmpty(_expectationComment))
{
writer.Write(" Comment: ");
writer.Write(_expectationComment);
}
writer.WriteLine();
}
/// <summary>
/// Create a new MetaAnnotationMatchingPointcut for the given annotation type.
/// </summary>
/// <param name="classAnnotationType"> the annotation type to look for at the class level </param>
/// <param name="checkInherited"> whether to explicitly check the superclasses and
/// interfaces for the annotation type as well (even if the annotation type
/// is not marked as inherited itself) </param>
public MetaAnnotationMatchingPointcut(Type classAnnotationType, bool checkInherited)
{
this.classFilter = new AnnotationClassFilter(classAnnotationType, checkInherited);
this.methodMatcher = MethodMatcher.TRUE;
}
/// <summary>Returns the first base class (not including Object) method which declares the specified method.
/// Note that this may return an abstract method, or the original method, or null if a base
/// type could not be found.</summary>
public static MethodDefinition GetBasestMethod(this MethodDefinition method, AssemblyCache cache)
{
DBC.Pre(method != null, "method is null");
DBC.Pre(cache != null, "cache is null");
MethodDefinition result = method;
if (method.IsVirtual)
{
TypeDefinition type = cache.FindType(method.DeclaringType);
if (type != null)
type = cache.FindType(type.BaseType);
while (type != null && type.FullName != "System.Object")
{
MethodMatcher matcher = new MethodMatcher(method);
MethodDefinition[] candidates = type.Methods.GetMethod(method.Name);
foreach (MethodDefinition candidate in candidates)
{
if (candidate.IsVirtual && !candidate.IsFinal && matcher == candidate)
result = candidate;
}
type = cache.FindType(type.BaseType);
}
if (type == null)
result = null;
}
return result;
}
private static TypeReference DoGetDeclaringInterface(TypeReference declared, MethodMatcher matcher, AssemblyCache cache)
{
Log.DebugLine(true, " finding {0}", declared.FullName);
TypeDefinition type = cache.FindType(declared);
if (type != null)
{
Log.DebugLine(true, " found {0}, {1} interfaces", type.FullName, type.Interfaces.Count);
foreach (TypeReference inRef in type.Interfaces)
{
Log.DebugLine(true, " references {0}", inRef.FullName);
TypeDefinition inType = cache.FindType(inRef);
if (inType != null)
{
Log.DebugLine(true, " checking {0}", inType);
if (DoDeclares(inType, matcher))
{
return inType;
}
}
}
}
return null;
}
private static bool DoDeclares(TypeDefinition type, MethodMatcher matcher)
{
foreach (MethodDefinition method in type.Methods)
{
if (matcher == method)
{
return true;
}
}
return false;
}
public DynamicVisitor(Type returnType, BindingFlags binding, System.Reflection.BindingFlags methodbinding, MethodMatcher matcher, params Type[] parameterTypes)
{
if (parameterTypes.Length == 0)
{
throw new Exception("Parameter types must have at least one element");
}
d_returnType = returnType;
d_parameterTypes = parameterTypes;
d_binding = binding;
d_methodBinding = methodbinding;
Scan(matcher);
}
public void MatchesPassingTest(MethodMetadata method, MethodMatcher matcher)
{
Assert.True(matcher.Matches(method));
}
