We must use an error of JCI problem objects. If there are no
problems, null is returned. These errors are placed in the
DroolsError instances. Its not 1 to 1 with reported errors.
423532
protected CompilationProblem[] collectCompilerProblems() {
        if (this.errors.isEmpty()) {
            return null;
        } else {
            final CompilationProblem[] list = new CompilationProblem[this.errors.size()];
            this.errors.toArray(list);
            return list;
        }
    }
1064013
function JModelError(obj) {
    this.message = obj['message'];
    this.propertyName = obj['propertyName'];

    Error.call(this);
    Error.captureStackTrace(this, this.constructor);
}
191930
public final void evalError() {
    final List<EvaluationMonitor<POSSample>> listeners = new LinkedList<EvaluationMonitor<POSSample>>();
    listeners.add(new POSEvaluationErrorListener());
    final POSEvaluator evaluator = new POSEvaluator(this.posTagger,
        listeners.toArray(new POSTaggerEvaluationMonitor[listeners.size()]));
    try {
      evaluator.evaluate(this.testSamples);
    } catch (IOException e) {
      e.printStackTrace();
    }
    System.out.println(evaluator.getWordAccuracy());
  }
801732
public List<String> getErrorMessages() {
        List<String> messages = new ArrayList<String>( errors.size() );

        for ( DroolsParserException activeException : errors ) {
            messages.add( activeException.getMessage() );
        }

        return messages;
    }
939638
@Override
    public ScopedMessageHandler errors() {
        if (errorsHandler == null) {
            synchronized (this) {
                if (errorsHandler == null) {
                    errorsHandler = createScopedMessageHandler(getErrorMessagesKey());
                }
            }
        }
        return errorsHandler;
    }
91559
public void queryError(HeadersAmp headers,
                         String to,
                         long qid,
                         Throwable exn)
    throws IOException
  {
    if (log.isLoggable(Level.FINEST)) {
      log.finest(this + " error " + exn
                + "\n  {to:" + to + "," + headers + "}");
      
    }
    
    if (log.isLoggable(Level.FINER)) {
      log.log(Level.FINER, exn.toString(), exn);
    }
    
    try {
      JsonWriterImpl jOut = _jOut;
      jOut.init();

      jOut.writeStartArray();
      jOut.write("error");

      writeHeaders(jOut, headers);

      jOut.write(to);
      jOut.write(qid);

      ErrorAmp error = ErrorAmp.create(exn);

      jOut.writeStartObject();
      jOut.writeKey("code");
      jOut.writeString(error.getCode().toString());
      
      jOut.writeKey("message");
      jOut.writeString(exn.getMessage());
      
      jOut.writeKey("class");
      jOut.writeString(exn.getClass().getName());
      
      jOut.writeEndObject();

      jOut.writeEndArray();

      jOut.close();
    } catch (Throwable e) {
      log.log(Level.WARNING, e.toString(), e);
      
      throw e;
    }
  }
1048741
public boolean containsErrors(
      java.lang.String key) {
    if (key == null) { throw new java.lang.NullPointerException(); }
    return internalGetErrors().getMap().containsKey(key);
  }
622681
def get_object_errors(self):
        
        if self._object_errors is None:
            self._object_errors = [{str(o): o.get_errors()}
                                   for o in self.objects()
                                   if o.has_error()]

        return self._object_errors
864869
public List getErrors() {
		if (hasChilds()) {
			List ret = new ArrayList(0);
			Iterator it = getChilds().iterator();
			while (it.hasNext()) {
				ret.addAll(((AbcNode) it.next()).getErrors());
			}
			return ret;
		} else {
			return errors != null ? errors : new ArrayList(0);
		}
	}
344347
public void error(Throwable error, Map<String, Object> custom) {
    error(error, custom, null);
  }
45774
function _connectionError() {
  _connectionError = _asyncToGenerator(
  /*#__PURE__*/
  _regeneratorRuntime.mark(function _callee8(originalError) {
    var count, addObj, text, newError;
    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
      while (1) {
        switch (_context8.prev = _context8.next) {
          case 0:
            _context8.next = 2;
            return countChannelFolders();

          case 2:
            count = _context8.sent;

            if (!(count < 30)) {
              _context8.next = 5;
              break;
            }

            return _context8.abrupt("return", originalError);

          case 5:
            addObj = {};
            Object.entries(originalError).forEach(function (_ref5) {
              var k = _ref5[0],
                  v = _ref5[1];
              return addObj[k] = v;
            });
            text = 'BroadcastChannel.create(): error: ' + 'This might happen if you have created to many channels, ' + 'like when you use BroadcastChannel in unit-tests.' + 'Try using BroadcastChannel.clearNodeFolder() to clear the tmp-folder before each test.' + 'See https://github.com/pubkey/broadcast-channel#clear-tmp-folder';
            newError = new Error(text + ': ' + JSON.stringify(addObj, null, 2));
            return _context8.abrupt("return", newError);

          case 10:
          case "end":
            return _context8.stop();
        }
      }
    }, _callee8);
  }));
  return _connectionError.apply(this, arguments);
}
1228668
private void addError(IValidationContext context, ConstraintViolation violation, JsonPointer pointer) {

		// extract the error code, if any
		final Class<? extends Annotation> annotationType = violation.getConstraintDescriptor().getAnnotation().annotationType();
		final IErrorCode validationCode = constraintConverter.getErrorCode(annotationType);
		final IErrorLocationType validationType = constraintConverter.getErrorLocationType(annotationType);

		// add the error to the validation context
		context.addError(pointer.toString(), validationType, validationCode, violation.getMessage());
	}
974291
@Override
    public boolean isAnError(final int lineNo) {
        for (int i = 0; i < errors.size(); i++) {
            if (errors.get(i).getLineNo() == lineNo && errors.get(i).getErrorLevel() > 1) {
                return true;
            }
        }
        return false;
    }
655393
@Override
    public AssertionError newAssertionError(Description d, Representation representation) {
        AssertionError assertionError = getComparisonFailureInstance();
        if (assertionError != null) {
            return assertionError;
        }

        String message = String.format(EXPECTED_BUT_WAS_MESSAGE, getActual(), getExpected());
        return Failures.instance().failure(message);
    }
974394
private void makeErrorList( final DRLParser parser ) {
        for ( final DroolsParserException recogErr : lexer.getErrors() ) {
            final ParserError err = new ParserError( resource,
                                                     recogErr.getMessage(),
                                                     recogErr.getLineNumber(),
                                                     recogErr.getColumn() );
            this.results.add( err );
        }
        for ( final DroolsParserException recogErr : parser.getErrors() ) {
            final ParserError err = new ParserError( resource,
                                                     recogErr.getMessage(),
                                                     recogErr.getLineNumber(),
                                                     recogErr.getColumn() );
            this.results.add( err );
        }
    }
349102
@Subscribe
    public void error(ReplicationErrored re) {
        Log.e(LOG_TAG, "Replication error:", re.errorInfo);
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (mListener != null) {
                    mListener.replicationError();
                }
            }
        });
    }
463019
public static String getError(JUnitTestData testMethod) {
        String error = "~";
        Throwable t = testMethod.getFailException();
        if (t != null) {
            error = t.getMessage();
        }
        return error;
    }