Unknown parameter(s) for {0}.{1} method annotated with @OnError annotation: {2}. This method will be ignored.
354919
public static String ENDPOINT_UNKNOWN_PARAMS(Object arg0, Object arg1, Object arg2) {
        return localizer.localize(localizableENDPOINT_UNKNOWN_PARAMS(arg0, arg1, arg2));
    }
522158
@Override
    public Result onError(Context context, String reason) {
        return Results.forbidden(reason);
    }
156724
@SuppressWarnings("all")
    public static Method findMethodOrThrowException(Class<?> type, String methodName, Class<?>... parameterTypes) {
        Method methodToMock = findMethod(type, methodName, parameterTypes);
        throwExceptionIfMethodWasNotFound(type, methodName, methodToMock, (Object[]) parameterTypes);
        return methodToMock;
    }
500528
@Override
    public void onError(final Throwable t) {

        Objects.requireNonNull(t);

        if (errorHandler != null)
            errorHandler.accept(t);

    }
114317
def method_missing(method_symbol, *method_args)
      if method_args.length > 0
        _set(method_symbol, method_args.first)
      end

      _get(method_symbol)
    end
482542
function onErrorResumeNext$2() {
    var nextSources = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        nextSources[_i - 0] = arguments[_i];
    }
    if (nextSources.length === 1 && isArray.isArray(nextSources[0])) {
        nextSources = nextSources[0];
    }
    return this.lift(new OnErrorResumeNextOperator(nextSources));
}
777476
static <T extends Throwable> T unknownStackTrace(T cause, Class<?> clazz, String method) {
        cause.setStackTrace(new StackTraceElement[] { new StackTraceElement(clazz.getName(), method, null, -1) });
        return cause;
    }
841604
function (err) {
        if (err) {
          reject(err);
        } else if (arguments.length === 2) { // single param?
          resolve(arguments[1]);
        } else { // multiple params?
          var cbArgsArray = self.toArgsArray(arguments);
          resolve(cbArgsArray.slice(1)); // remove err arg
        }
      }
24561
public static void validateParameters(Object instance, Method method, Object[] params) {
        Assert.notNull(instance, "instance不能为null");
        Assert.notNull(method, "method不能为null");
        Set<ConstraintViolation<Object>> constraintViolations = executableValidator
            .validateParameters(instance, method, params);
        check(constraintViolations);
    }
182657
def method_missing(method, *args, &code)
    success = false
    result  = nil

    if method.to_s.match(/^set\_([a-z].*)$/)
      name = $1.to_sym

      if @types.has_key?(name) && args.length > 2
        @types[name].set([ args[0], args[1] ], args[2]) if args.length > 2
        success = true
      end

    elsif method.to_s.match(/^remove\_([a-z].*)$/)
      name = $1.to_sym

      if @types.has_key?(name) && args.length > 0
        @types[name].delete([ args[0], args[1] ])
        success = true
      end

    else
      name = @plurals[method.to_sym]

      if name && @types.has_key?(name)
        result  = @types[name]
        success = true
      end
    end
    super unless success # Raise NoMethodError
    result
  end
870048
def method_missing(name, *args, &block)
      getter_name = name[0..-2]

      if name =~ /^[a-z]+=$/ && !respond_to?(getter_name)
        define_accessor(getter_name, args.first)
      else
        super
      end
    end
896951
def method_missing(*args, &block)
      Thread.pass until defined?(@result)
      
      case @result
      when Exception
        def self.method_missing(*args, &block); raise @result; end
      else
        def self.method_missing(*args, &block); @result.send(*args, &block); end
      end
      
      self.method_missing(*args, &block)
    end
765988
@SafeVarargs
    private static void checkNoAnnotations(Method method, Class<? extends Annotation> foundAn,
            Class<? extends Annotation>... disallowedAn) {

        for (Class<? extends Annotation> an : disallowedAn) {
            if (method.isAnnotationPresent(an)) {
                throw new EventsException("Method " + Utils.methodToString(method)
                        + " marked with @" + foundAn.getSimpleName()
                        + " cannot be marked with @" + an.getSimpleName());
            }
        }
    }
846125
def method_missing(name, *args)
      value = @values[name]
      if value.nil? && !@values.has_key?(name)
        address = "<#{self.class.name}:0x00#{(self.object_id << 1).to_s(16)}>"
        raise NoMethodError.new("undefined method `#{name}' for ##{address}")
      end
      value
    end
984313
@Override
    public void onError(Session session, Throwable thr) {
        if (onError != null) {
            Object args[] = new Object[onError.getMethod().getParameterTypes().length];
            MethodData methodData = onError.getMethodData();
            //check if method has optional Session parameter
            int sessionIndex = methodData.getSessionIndex();
            if (sessionIndex >= 0) {
                args[sessionIndex] = session;
            }
            int throableIndx = methodData.getThrowableIndex();
            if (throableIndx >= 0) {
                args[throableIndx] = thr;
            }
            if (shouldProcessPath) {
                try {
                    //substitute values for @PathParam values for this method.
                    onError.processPathParameters(this, args);
                } catch (DecodeException e) {
                    //We can not call onError() again for this since that will result in infinite loop. This is a double error situation,
                    //1) First exception is original exception 'thr' which onError method is called for
                    //2) Secondly, while processing @OnError method's pathparam, there is an exception. Spec is not clear on how to report both exceptions to the user.
                    //We report DecodeException (@PathParam processing issue) first, so that user can correct their @Pathparam parameter in their app
                    //For e.g onError() method, if user has declared parameter as 'int vipLevel'and passed value for vipLevel as 'xyz' by mistake, DecodeException
                    //will occur here and they need to correct it first anyway. Then, for the next invocation user's onError(..) is called with the exception why the
                    //onError(..) is invoked for.
                    thr = e;
                }
            }

            try {

                if (appInstance == null) {
                    if (tc.isDebugEnabled()) {
                        Tr.debug(tc, "application instance is null in onError");
                    }
                    return;
                }

                onError.getMethod().invoke(appInstance, args);

            } catch (IllegalAccessException e) {
                // allow instrumented FFDC to be used here
            } catch (IllegalArgumentException e) {
                // allow instrumented FFDC to be used here
            } catch (InvocationTargetException e) {
                // allow instrumented FFDC to be used here
            }
        } else { //onError() is not defined
            //JSR 356 5.2.2 -->"If the developer has not provided an error handling method on an endpoint that is generating errors, this
            //indicates to the implementation that the developer does not wish to handle such errors. In these cases, the
            //container must make this information available for later analysis, for example by logging it. [WSC-5.2.2-3]"
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "Trying to report error: '" + thr.getMessage() + "' calling onError(). However onError() is not defined on the endpoint: " + sepClass.getName());
            }
            //log in FFDC since we could not report it back to the user
            FFDCFilter.processException(thr, getClass().getName(), "288", this);
        }
    }
736179
def check_parameters
      errors = ""
      @url.scan(/:(\w*)/).flatten.map(&:to_sym).each do |arg|
        errors += "<li><p>parameter '#{arg.to_s}' is required</p></li>" unless @attributes.has_key?(arg)
      end
      errors.empty? ? "" : "<ul>#{errors}</ul>"
    end
423273
private static int findIndexOfValue(final Method method) {
        int index = 0;
        for (Annotation[] annotations : method.getParameterAnnotations()) {
            for (Annotation a : annotations) {
                if (XBValue.class.equals(a.annotationType())) {
                    return index;
                }
            }
            ++index;
        }
        return 0; // If no attribute is annotated, the first one is taken.
    }