コード例 #1
0
 /**
  * Assert that the number of errors that have been gathered matches the number of severities that
  * are given and that there are the same number of errors and warnings as specified by the
  * argument. The order in which the errors were gathered is ignored.
  *
  * @param expectedSeverities the severities of the errors that should have been gathered
  * @throws AssertionFailedError if a different number of errors have been gathered than were
  *     expected
  */
 public void assertErrors(ErrorSeverity... expectedSeverities) {
   int expectedErrorCount = 0;
   int expectedWarningCount = 0;
   for (ErrorSeverity severity : expectedSeverities) {
     if (severity == ErrorSeverity.ERROR) {
       expectedErrorCount++;
     } else {
       expectedWarningCount++;
     }
   }
   int actualErrorCount = 0;
   int actualWarningCount = 0;
   for (AnalysisError error : errors) {
     if (error.getErrorCode().getErrorSeverity() == ErrorSeverity.ERROR) {
       actualErrorCount++;
     } else {
       actualWarningCount++;
     }
   }
   if (expectedErrorCount != actualErrorCount || expectedWarningCount != actualWarningCount) {
     Assert.fail(
         "Expected "
             + expectedErrorCount
             + " errors and "
             + expectedWarningCount
             + " warnings, found "
             + actualErrorCount
             + " errors and "
             + actualWarningCount
             + " warnings");
   }
 }
コード例 #2
0
 /**
  * Return {@code true} if an error with the given error code has been gathered.
  *
  * @param errorCode the error code being searched for
  * @return {@code true} if an error with the given error code has been gathered
  */
 public boolean hasError(ErrorCode errorCode) {
   for (AnalysisError error : errors) {
     if (error.getErrorCode() == errorCode) {
       return true;
     }
   }
   return false;
 }
コード例 #3
0
 @Override
 public void onError(AnalysisError error) {
   if (rawSource != null) {
     int left = error.getOffset();
     int right = left + error.getLength() - 1;
     markedSource =
         rawSource.substring(0, left)
             + "^"
             + rawSource.substring(left, right)
             + "^"
             + rawSource.substring(right);
   }
   errors.add(error);
 }
コード例 #4
0
 /**
  * Assert that the number of errors that have been gathered matches the number of errors that are
  * given and that they have the expected error codes. The order in which the errors were gathered
  * is ignored.
  *
  * @param expectedErrorCodes the error codes of the errors that should have been gathered
  * @throws AssertionFailedError if a different number of errors have been gathered than were
  *     expected
  */
 public void assertErrors(ErrorCode... expectedErrorCodes) {
   StringBuilder builder = new StringBuilder();
   //
   // Compute the expected number of each type of error.
   //
   HashMap<ErrorCode, Integer> expectedCounts = new HashMap<ErrorCode, Integer>();
   for (ErrorCode code : expectedErrorCodes) {
     Integer count = expectedCounts.get(code);
     if (count == null) {
       count = Integer.valueOf(1);
     } else {
       count = Integer.valueOf(count.intValue() + 1);
     }
     expectedCounts.put(code, count);
   }
   //
   // Compute the actual number of each type of error.
   //
   HashMap<ErrorCode, ArrayList<AnalysisError>> errorsByCode =
       new HashMap<ErrorCode, ArrayList<AnalysisError>>();
   for (AnalysisError error : errors) {
     ErrorCode code = error.getErrorCode();
     ArrayList<AnalysisError> list = errorsByCode.get(code);
     if (list == null) {
       list = new ArrayList<AnalysisError>();
       errorsByCode.put(code, list);
     }
     list.add(error);
   }
   //
   // Compare the expected and actual number of each type of error.
   //
   for (Map.Entry<ErrorCode, Integer> entry : expectedCounts.entrySet()) {
     ErrorCode code = entry.getKey();
     int expectedCount = entry.getValue().intValue();
     int actualCount;
     ArrayList<AnalysisError> list = errorsByCode.remove(code);
     if (list == null) {
       actualCount = 0;
     } else {
       actualCount = list.size();
     }
     if (actualCount != expectedCount) {
       if (builder.length() == 0) {
         builder.append("Expected ");
       } else {
         builder.append("; ");
       }
       builder.append(expectedCount);
       builder.append(" errors of type ");
       builder.append(code);
       builder.append(", found ");
       builder.append(actualCount);
     }
   }
   //
   // Check that there are no more errors in the actual-errors map, otherwise, record message.
   //
   for (Map.Entry<ErrorCode, ArrayList<AnalysisError>> entry : errorsByCode.entrySet()) {
     ErrorCode code = entry.getKey();
     ArrayList<AnalysisError> actualErrors = entry.getValue();
     int actualCount = actualErrors.size();
     if (builder.length() == 0) {
       builder.append("Expected ");
     } else {
       builder.append("; ");
     }
     builder.append("0 errors of type ");
     builder.append(code);
     builder.append(", found ");
     builder.append(actualCount);
     builder.append(" (");
     for (int i = 0; i < actualErrors.size(); i++) {
       AnalysisError error = actualErrors.get(i);
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(error.getOffset());
     }
     builder.append(")");
   }
   if (builder.length() > 0) {
     Assert.fail(builder.toString());
   }
 }
コード例 #5
0
 /**
  * Assert that the number of errors that have been gathered matches the number of errors that are
  * given and that they have the expected error codes. The order in which the errors were gathered
  * is ignored.
  *
  * @param errorCodes the errors that should have been gathered
  * @throws AssertionFailedError with
  */
 private void fail(AnalysisError[] expectedErrors) {
   PrintStringWriter writer = new PrintStringWriter();
   writer.print("Expected ");
   writer.print(expectedErrors.length);
   writer.print(" errors:");
   for (AnalysisError error : expectedErrors) {
     Source source = error.getSource();
     File file = source == null ? null : source.getFile();
     LineInfo lineInfo = lineInfoMap.get(source);
     writer.println();
     if (lineInfo == null) {
       int offset = error.getOffset();
       writer.printf(
           "  %s %s (%d..%d)",
           file == null ? "" : file.getName(),
           error.getErrorCode(),
           offset,
           offset + error.getLength());
     } else {
       LineInfo.Location location = lineInfo.getLocation(error.getOffset());
       writer.printf(
           "  %s %s (%d, %d/%d)",
           source == null ? "" : source.getFile().getName(),
           error.getErrorCode(),
           location.getLineNumber(),
           location.getColumnNumber(),
           error.getLength());
     }
   }
   writer.println();
   writer.print("found ");
   writer.print(errors.size());
   writer.print(" errors:");
   for (AnalysisError error : errors) {
     Source source = error.getSource();
     File file = source == null ? null : source.getFile();
     LineInfo lineInfo = lineInfoMap.get(source);
     writer.println();
     if (lineInfo == null) {
       int offset = error.getOffset();
       writer.printf(
           "  %s %s (%d..%d): %s",
           file == null ? "" : file.getName(),
           error.getErrorCode(),
           offset,
           offset + error.getLength(),
           error.getMessage());
     } else {
       LineInfo.Location location = lineInfo.getLocation(error.getOffset());
       writer.printf(
           "  %s %s (%d, %d/%d): %s",
           source == null ? "" : source.getFile().getName(),
           error.getErrorCode(),
           location.getLineNumber(),
           location.getColumnNumber(),
           error.getLength(),
           error.getMessage());
     }
   }
   Assert.fail(writer.toString());
 }
コード例 #6
0
 /**
  * Return {@code true} if the two errors are equivalent.
  *
  * @param firstError the first error being compared
  * @param secondError the second error being compared
  * @return {@code true} if the two errors are equivalent
  */
 private boolean equals(AnalysisError firstError, AnalysisError secondError) {
   return firstError.getErrorCode() == secondError.getErrorCode()
       && firstError.getOffset() == secondError.getOffset()
       && firstError.getLength() == secondError.getLength()
       && equals(firstError.getSource(), secondError.getSource());
 }