private static T getAnnotation <T>(ProcessEngine processEngine, Type testClass, string methodName, Type annotationClass) where T : Annotation { annotationClass = typeof(T); System.Reflection.MethodInfo method = null; T annotation = null; try { method = getMethod(testClass, methodName); annotation = method.getAnnotation(annotationClass); } catch (Exception) { // - ignore if we cannot access the method // - just try again with the class // => can for example be the case for parameterized tests where methodName does not correspond to the actual method name // (note that method-level annotations still work in this // scenario due to Description#getAnnotation in annotationRequiredHistoryLevelCheck) } // if not found on method, try on class level if (annotation == null) { annotation = testClass.getAnnotation(annotationClass); } return(annotation); }
private static string NameOf(System.Reflection.MethodInfo method) { Name name = method.getAnnotation(typeof(Name)); if (name != null) { return(name.value()); } return(method.Name); }
public static string ExtractMessage(System.Reflection.MethodInfo method) { string message; Documented annotation = method.getAnnotation(typeof(Documented)); if (annotation != null && !"".Equals(annotation.value())) { message = annotation.value(); } else { message = method.Name; } return(message); }
public override object Invoke(object proxy, System.Reflection.MethodInfo method, object[] args) { string message = DocumentedUtils.extractFormattedMessage(method, args); if (method.getAnnotation(typeof(ConsistencyReport_Warning)) == null) { Errors++; Report.error(message); } else { Warnings++; Report.warning(message); } return(null); }
/// <summary> /// Invoked when an inconsistency is encountered. /// </summary> /// <param name="args"> array of the items referenced from this record with which it is inconsistent. </param> public override object Invoke(object proxy, System.Reflection.MethodInfo method, object[] args) { string message = DocumentedUtils.extractMessage(method); if (method.getAnnotation(typeof(ConsistencyReport_Warning)) == null) { Errors++; args = GetRealRecords(args); LogError(message, args); } else { Warnings++; args = GetRealRecords(args); LogWarning(message, args); } Monitor.reported(Factory.type(), method.Name, message); InconsistencyReported(); return(null); }
public override PluginPoint CreateFrom(ServerPlugin plugin, System.Reflection.MethodInfo method, Type discovery) { ResultConverter result = ResultConverter.Get(method.GenericReturnType); Type[] types = method.GenericParameterTypes; Annotation[][] annotations = method.ParameterAnnotations; SourceExtractor sourceExtractor = null; DataExtractor[] extractors = new DataExtractor[types.Length]; for (int i = 0; i < types.Length; i++) { Description description = null; Parameter param = null; Source source = null; foreach (Annotation annotation in annotations[i]) { if (annotation is Description) { description = ( Description )annotation; } else if (annotation is Parameter) { param = ( Parameter )annotation; } else if (annotation is Source) { source = ( Source )annotation; } } if (param != null && source != null) { throw new System.InvalidOperationException(string.Format("Method parameter {0:D} of {1} cannot be retrieved as both Parameter and Source", Convert.ToInt32(i), method)); } else if (source != null) { if (types[i] != discovery) { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: throw new System.InvalidOperationException("Source parameter type (" + types[i] + ") must equal the discovery type (" + discovery.FullName + ")."); } if (sourceExtractor != null) { throw new System.InvalidOperationException("Server Extension methods may have at most one Source parameter."); } extractors[i] = sourceExtractor = new SourceExtractor(source, description); } else if (param != null) { extractors[i] = ParameterExtractor(types[i], param, description); } else { throw new System.InvalidOperationException("Parameters of Server Extension methods must be annotated as either Source or Parameter."); } } return(new PluginMethod(NameOf(method), discovery, plugin, result, method, extractors, method.getAnnotation(typeof(Description)))); }
public static string annotationDeploymentSetUp(ProcessEngine processEngine, Type testClass, string methodName, Deployment deploymentAnnotation) { string deploymentId = null; System.Reflection.MethodInfo method = null; bool onMethod = true; try { method = getMethod(testClass, methodName); } catch (Exception) { if (deploymentAnnotation == null) { // we have neither the annotation, nor can look it up from the method return(null); } } if (deploymentAnnotation == null) { deploymentAnnotation = method.getAnnotation(typeof(Deployment)); } // if not found on method, try on class level if (deploymentAnnotation == null) { onMethod = false; Type lookForAnnotationClass = testClass; while (lookForAnnotationClass != typeof(object)) { deploymentAnnotation = lookForAnnotationClass.getAnnotation(typeof(Deployment)); if (deploymentAnnotation != null) { testClass = lookForAnnotationClass; break; } lookForAnnotationClass = lookForAnnotationClass.BaseType; } } if (deploymentAnnotation != null) { LOG.debug("annotation @Deployment creates deployment for {}.{}", ClassNameUtil.getClassNameWithoutPackage(testClass), methodName); string[] resources = deploymentAnnotation.resources(); if (resources.Length == 0 && method != null) { string name = onMethod ? method.Name : null; string resource = getBpmnProcessDefinitionResource(testClass, name); resources = new string[] { resource }; } DeploymentBuilder deploymentBuilder = processEngine.RepositoryService.createDeployment().name(ClassNameUtil.getClassNameWithoutPackage(testClass) + "." + methodName); foreach (string resource in resources) { deploymentBuilder.addClasspathResource(resource); } deploymentId = deploymentBuilder.deploy().Id; } return(deploymentId); }