should not be overriden in subclasses
771999
def process_exception(exception) #:nodoc:
      if @error_callback
        @error_callback.call(message, exception)
      else
        error(exception)
      end
    rescue Exception
      Beetle::reraise_expectation_errors!
    end
520355
private static void applyOverrides() {
        // Get the appropriate InputStream to read overrides from, if any.
        InputStream stream = getContentTypesPropertiesStream();
        if (stream == null) {
            return;
        }

        try {
            try {
                // Read the properties file...
                Properties overrides = new Properties();
                overrides.load(stream);
                // And translate its mapping to ours...
                for (Map.Entry<Object, Object> entry : overrides.entrySet()) {
                    String extension = (String) entry.getKey();
                    String mimeType = (String) entry.getValue();
                    add(mimeType, extension);
                }
            } finally {
                stream.close();
            }
        } catch (IOException ignored) {
        }
    }
1276348
def inherited(subclass)
      subclass._arguments = []
      subclass._description = ''
      subclass._abstract = false
      subclass._skip_options = false
      subclass._exe_name = @_exe_name
      subclass._default_priority = @_default_priority.to_f / 2
      subclass._priority = 0
      super
    end
1152024
public static boolean isSubclassOf(ClassNode classNode, String parentClassName) {
        ClassNode currentSuper = classNode.getSuperClass();
        while (currentSuper != null && !currentSuper.getName().equals(OBJECT_CLASS)) {
            if (currentSuper.getName().equals(parentClassName)) return true;
            currentSuper = currentSuper.getSuperClass();
        }
        return false;
    }
607087
public static boolean isMethodOverridden(Method m, LinkedList<Class<?>> supers)
    {
        // Only check non-private methods for an override.
        int methodModifier = m.getModifiers();
        if (!Modifier.isPrivate(methodModifier))
        {
            // Not a private method, so we need to check if it is overridden.
            int startIndex = supers.indexOf(m.getDeclaringClass()) + 1;
            if (startIndex < supers.size())
            {
                String name = m.getName();
                Class<?>[] pTypes = m.getParameterTypes();
                for (ListIterator<Class<?>> lit = supers.listIterator(startIndex); lit.hasNext();)
                {
                    Class<?> subClass = lit.next();
                    try
                    {
                        subClass.getDeclaredMethod(name, pTypes);
                        return true;
                    } catch (NoSuchMethodException e)
                    {
                        //FFDCFilter.processException( e, "", "", m);
                        // This is normal, it just means the method was not overridden
                        // by a method in the current subclass being processed.
                    }
                }
            }
        }

        // The method is not overridden either because it is a private method,
        // or there is no subclass that overrides the method.
        return false;
    }
1234660
public boolean overrides(ExecutableElement e1, ExecutableElement e2, TypeElement cls) {
        MethodSymbol rider = (MethodSymbol)e1;
        MethodSymbol ridee = (MethodSymbol)e2;
        ClassSymbol origin = (ClassSymbol)cls;

        return rider.name == ridee.name &&

               // not reflexive as per JLS
               rider != ridee &&

               // we don't care if ridee is static, though that wouldn't
               // compile
               !rider.isStatic() &&

               // Symbol.overrides assumes the following
               ridee.isMemberOf(origin, toolEnv.getTypes()) &&

               // check access, signatures and check return types
               rider.overrides(ridee, origin, toolEnv.getTypes(), true);
    }
139098
def must_be_same(self, klass):
        """"""
        if self.__class__ is not klass:
            self.__class__ = klass
            self._morph()
            self.clear()
314405
void expectSuperType(Node n, ObjectType superObject, ObjectType subObject) {
    FunctionType subCtor = subObject.getConstructor();
    ObjectType implicitProto = subObject.getImplicitPrototype();
    ObjectType declaredSuper =
        implicitProto == null ? null : implicitProto.getImplicitPrototype();
    if (declaredSuper != null && declaredSuper.isTemplatizedType()) {
      declaredSuper =
          declaredSuper.toMaybeTemplatizedType().getReferencedType();
    }
    if (declaredSuper != null
        && !(superObject instanceof UnknownType)
        && !declaredSuper.isEquivalentTo(superObject)) {
      if (declaredSuper.isEquivalentTo(getNativeType(OBJECT_TYPE))) {
        registerMismatch(
            superObject,
            declaredSuper,
            report(JSError.make(n, MISSING_EXTENDS_TAG_WARNING, subObject.toString())));
      } else {
        mismatch(n, "mismatch in declaration of superclass type", superObject, declaredSuper);
      }

      // Correct the super type.
      if (!subCtor.hasCachedValues()) {
        subCtor.setPrototypeBasedOn(superObject);
      }
    }
  }
1016306
private Description checkSubtype(ClassTree tree, VisitorState state) {
    ClassSymbol sym = ASTHelpers.getSymbol(tree);
    if (sym == null) {
      return NO_MATCH;
    }
    Type superType = immutableSupertype(sym, state);
    if (superType == null) {
      return NO_MATCH;
    }
    String message =
        String.format(
            "Class extends @Immutable type %s, but is not annotated as immutable", superType);
    Fix fix =
        SuggestedFix.builder()
            .prefixWith(tree, "@Immutable ")
            .addImport(Immutable.class.getName())
            .build();
    return buildDescription(tree).setMessage(message).addFix(fix).build();
  }
522329
def _subclassed(base, *classes):
        
        return all(map(lambda obj: isinstance(obj, base), classes))
453370
def _unique_class(self, cls):
        
        return not any(isinstance(obj, cls) for obj in self.plugins)
1073923
def subclass(self, klass):
        """"""
        return bool(lib.EnvSubclassP(self._env, self._cls, klass._cls))
1198419
def _unregister(self, cls):
        
        if not issubclass(cls, self._registerable_class):
            raise ValueError('Only %s classes or subclasses may be '
                             'unregistered.' % self._registerable_class)

        if cls not in self._registry:
            raise NotRegistered('%s is not registered' % cls)

        del self._registry[cls]

        return True
1147804
public static boolean overrides(
      TypeElement type, Types types, String methodName, TypeMirror... params) {
    return override(type, types, methodName, params).isPresent();
  }
269221
def _enforce_instance(model_or_class):
    
    if isinstance(model_or_class, type) and issubclass(model_or_class, BaseType):
        return model_or_class()
    return model_or_class
329396
def remove_override(self, key):
        """"""
        keys = key.split('.')
        if len(keys) > 1:
            raise NotImplementedError
        elif key in self.overrides:
            del self.overrides[key]
            self._uncache(key)
1004018
def ctor_overridable(cls):
    """"""
    prev_init = getattr(cls, "__init__", None)
    if not callable(prev_init):
        return True
    if prev_init in [object.__init__, _auto_init]:
        return True
    if getattr(prev_init, '_clobber_ok', False):
        return True

    print(cls, prev_init, getattr(prev_init, '_clobber_ok', 'missing'))
    return False