may be replaced by the New method - however the New method is not yet fully tested so this is stil used.
960339
public HttpMethod createRequestMethod(HttpRequestHeader header, HttpBody body) throws URIException {
		return createRequestMethod(header, body, null);
	}
106992
def method_missing(method, *arguments, &block)
      super if @finalized
      if arguments.length == 1 && arguments.first.is_a?(Directive)
        arguments.first.add_modifier Modifier.new(method)
      else
        (directives.push Directive.new(method)).last
      end
    end
310096
def method_missing(method, *args)
      method = method.to_s
      method_class = method_as_class(method)
      options = args.last.is_a?(Hash) ? args.pop : {}

      FreshdeskAPI::Collection.new(self, method_class, options)
    end
397956
def _update_method(self, oldmeth, newmeth):
        """"""
        # XXX What if im_func is not a function?
        if hasattr(oldmeth, 'im_func') and hasattr(newmeth, 'im_func'):
            self._update(None, None, oldmeth.im_func, newmeth.im_func)
        elif hasattr(oldmeth, '__func__') and hasattr(newmeth, '__func__'):
            self._update(None, None, oldmeth.__func__, newmeth.__func__)
        return oldmeth
1093451
public void referencedElementUpdated(ModelElementInstance referenceTargetElement, String oldIdentifier, String newIdentifier) {
    for (ModelElementInstance referenceSourceElement : findReferenceSourceElements(referenceTargetElement)) {
      updateReference(referenceSourceElement, oldIdentifier, newIdentifier);
    }
  }
981952
def method_missing(meth, *args, &block)
      # Check to see if it can be evaluated
      if(matches? meth)
        #Defines the method and caches it to the class
        self.class.send(:define_method, meth) do
          # Splits the method and parameter. See formatize and directionize
          send directionize(meth).to_sym, formatize(meth)
        end
        # calls the method
        send meth, *args, &block
      else
        super
      end
    end
165748
function _keepProps(method, newMethod) {
  var props = ['methodName', 'params', 'removeOutput'];
  _lodash2.default.extend(newMethod, _lodash2.default.pick(method, props));
  return newMethod;
}
1205513
private void updateMethodMap(Map<RequestMethod, List<Integer>> methodMap, Integer roleId, String methodMask) {
        for (int i = 0; i < RoleResourceConstant.METHOD_NUM; ++i) {
            if (methodMask.charAt(i) == RoleResourceConstant.METHOD_IS_ACCESSIBLE) {
                RequestMethod curMethod = RoleResourceConstant.IND_METHOD_MAP.get(i);

                // update List<roleId>
                List<Integer> roleIdList = methodMap.get(curMethod);
                if (roleIdList == null) {
                    roleIdList = new ArrayList<Integer>();
                    methodMap.put(curMethod, roleIdList);
                }
                roleIdList.add(roleId);
            }
        }
    }
1129721
function finalizeMeasurement(id) {
        if (activeTests[id.id]) {
            delete activeTests[id.id];
        }

        if (updatableTests[id.id]) {
            delete updatableTests[id.id];
        }
    }
1302028
def method_already_there(object_type, method_name, this_class_only=False):
    
    if this_class_only:
        return method_name in vars(object_type)  # or object_type.__dict__
    else:
        try:
            method = getattr(object_type, method_name)
        except AttributeError:
            return False
        else:
            return method is not None and method is not getattr(object, method_name, None)
367627
def _patched_method(self, method, *args, **kwargs):
        
        self._validate()
        result = method(*args, **kwargs)
        self._validate()
        return result
808609
public void changeEncoding(int newEncoding) {
        if (this.encoding != newEncoding) {
            int oldEncoding = this.encoding;
            // Transform the quality scores, if necessary
            this.transformQualityScoresArray(oldEncoding, newEncoding);

            // Transform the quality string
            this.obtainQualityStringFromQualityScoresArray(newEncoding);
            this.encoding = newEncoding;
        }
    }
349690
private boolean isFixtureMethod(MethodNode method) {
    String name = method.getName();

    for (String fmName : FIXTURE_METHODS) {
      if (!fmName.equalsIgnoreCase(name)) continue;

      // assertion: is (meant to be) a fixture method, so we'll return true in the end

      if (method.isStatic())
        errorReporter.error(method, "Fixture methods must not be static");
      if (!fmName.equals(name))
        errorReporter.error(method, "Misspelled '%s()' method (wrong capitalization)", fmName);

      return true;
    }

    return false;
  }
713233
def method_missing msg, *args, &block
      defi = Definition.new(msg, args, block)
      if injected = __mock_injected[defi.msg]
        defi.original_method = injected.original_method
      else
        __mock_inject_method(defi)
      end
      __mock_defis_push(defi)
      Modifier.new(self, defi)
    end
224512
private static void removeMethodByName(Method method, List<Method> methods) {
    if(methods != null) {
      Iterator<Method> itr = methods.iterator();
      Method aMethod = null;
      while(itr.hasNext()) {
        aMethod = itr.next();
        if(aMethod.getName().equals(method.getName())) {
          itr.remove();
          break;
        }
      }
      if(aMethod != null) {
        methods.add(aMethod);
      }
    }
  }
1034705
function(newProps) {
        if (this.getInitialState) {
            if (this.getInitialProps) {
                newProps = this.getInitialProps(newProps) || {};
            }
            var newState = this.getInitialState(newProps);
            this.replaceState(newState);
            return;
        }

        if (!this.__newProps) {
            updateManager.queueWidgetUpdate(this);
        }

        this.__newProps = newProps;
    }
280988
private void updateDecoration() {
        if (lastResult != null) {
            if (lastResult) {
                setIcon(validIcon);
                setToolTipText(validText);
            } else {
                setIcon(invalidIcon);
                setToolTipText(invalidText);
            }
        }
    }