Issue 8742. Preserve leading line comments during java2dart translation.

pkg/analyzer/test/generated/test_support.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.test_support;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 89 matching lines @@
    * 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
    */
   void assertErrors2(List<ErrorCode> expectedErrorCodes) {
     JavaStringBuilder builder = new JavaStringBuilder();
+    //
+    // Verify that the expected error codes have a non-empty message.
+    //
     for (ErrorCode errorCode in expectedErrorCodes) {
       JUnitTestCase.assertFalseMsg("Empty error code message", errorCode.message.isEmpty);
     }
+    //
+    // Compute the expected number of each type of error.
+    //
     Map<ErrorCode, int> expectedCounts = new Map<ErrorCode, int>();
     for (ErrorCode code in expectedErrorCodes) {
       int count = expectedCounts[code];
       if (count == null) {
         count = 1;
       } else {
         count = count + 1;
       }
       expectedCounts[code] = count;
     }
+    //
+    // Compute the actual number of each type of error.
+    //
     Map<ErrorCode, List<AnalysisError>> errorsByCode = new Map<ErrorCode, List<AnalysisError>>();
     for (AnalysisError error in _errors) {
       ErrorCode code = error.errorCode;
       List<AnalysisError> list = errorsByCode[code];
       if (list == null) {
         list = new List<AnalysisError>();
         errorsByCode[code] = list;
       }
       list.add(error);
     }
+    //
+    // Compare the expected and actual number of each type of error.
+    //
     for (MapEntry<ErrorCode, int> entry in getMapEntrySet(expectedCounts)) {
       ErrorCode code = entry.getKey();
       int expectedCount = entry.getValue();
       int actualCount;
       List<AnalysisError> list = errorsByCode.remove(code);
       if (list == null) {
         actualCount = 0;
       } else {
         actualCount = list.length;
       }
       if (actualCount != expectedCount) {
         if (builder.length == 0) {
           builder.append("Expected ");
         } else {
           builder.append("; ");
         }
         builder.append(expectedCount);
         builder.append(" errors of type ");
         builder.append("${code.runtimeType.toString()}.${code}");
         builder.append(", found ");
         builder.append(actualCount);
       }
     }
+    //
+    // Check that there are no more errors in the actual-errors map, otherwise, record message.
+    //
     for (MapEntry<ErrorCode, List<AnalysisError>> entry in getMapEntrySet(errorsByCode)) {
       ErrorCode code = entry.getKey();
       List<AnalysisError> actualErrors = entry.getValue();
       int actualCount = actualErrors.length;
       if (builder.length == 0) {
         builder.append("Expected ");
       } else {
         builder.append("; ");
       }
       builder.append("0 errors of type ");
@@ skipping 343 matching lines @@
         JUnitTestCase.assertTrueMsg("Content not as expected: is 'null' expected: ${expected}", false);
       } else {
         JUnitTestCase.assertTrueMsg("Content not as expected: expected 'null' is: ${actual}", false);
       }
     }
     int diffPos = getDiffPos(expected, actual);
     if (diffPos != -1) {
       int diffAhead = Math.max(0, diffPos - _PRINT_RANGE);
       int diffAfter = Math.min(actual.length, diffPos + _PRINT_RANGE);
       String diffStr = "${actual.substring(diffAhead, diffPos)}^${actual.substring(diffPos, diffAfter)}";
+      // use detailed message
       String message = "Content not as expected: is\n${actual}\nDiffers at pos ${diffPos}: ${diffStr}\nexpected:\n${expected}";
       JUnitTestCase.assertEqualsMsg(message, expected, actual);
     }
   }
 
   /**
    * Assert that the given list is non-`null` and has exactly expected elements.
    *
    * @param list the list being tested
    * @param expectedElements the expected elements
@@ skipping 341 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }