Remove trailing spaces in analyzer_experimental

pkg/analyzer_experimental/test/generated/scanner_test.dart

 // 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.scanner_test;
-
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
-
 class KeywordStateTest extends JUnitTestCase {
   void test_KeywordState() {
     List<Keyword> keywords = Keyword.values;
     int keywordCount = keywords.length;
     List<String> textToTest = new List<String>(keywordCount * 3);
     for (int i = 0; i < keywordCount; i++) {
       String syntax2 = keywords[i].syntax;
       textToTest[i] = syntax2;
       textToTest[i + keywordCount] = "${syntax2}x";
       textToTest[i + keywordCount * 2] = syntax2.substring(0, syntax2.length - 1);
@@ skipping 98 matching lines @@
         final __test = new TokenTypeTest();
         runJUnitTest(__test, __test.test_isOperator);
       });
       _ut.test('test_isUserDefinableOperator', () {
         final __test = new TokenTypeTest();
         runJUnitTest(__test, __test.test_isUserDefinableOperator);
       });
     });
   }
 }
-
 /**
  * The class {@code TokenFactory} defines utility methods that can be used to create tokens.
  */
 class TokenFactory {
   static Token token(Keyword keyword) => new KeywordToken(keyword, 0);
   static Token token2(String lexeme) => new StringToken(TokenType.STRING, lexeme, 0);
   static Token token3(TokenType type) => new Token(type, 0);
   static Token token4(TokenType type, String lexeme) => new StringToken(type, lexeme, 0);
 }
 class CharBufferScannerTest extends AbstractScannerTest {
@@ skipping 1325 matching lines @@
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_tilde_slash_eq);
       });
       _ut.test('test_unclosedPairInInterpolation', () {
         final __test = new StringScannerTest();
         runJUnitTest(__test, __test.test_unclosedPairInInterpolation);
       });
     });
   }
 }
-
 /**
  * Instances of the class {@code TokenStreamValidator} are used to validate the correct construction
  * of a stream of tokens.
  */
 class TokenStreamValidator {
-  
+
   /**
    * Validate that the stream of tokens that starts with the given token is correct.
    * @param token the first token in the stream of tokens to be validated
    */
   void validate(Token token) {
     JavaStringBuilder builder = new JavaStringBuilder();
     validateStream(builder, token);
     if (builder.length > 0) {
       JUnitTestCase.fail(builder.toString());
     }
@@ skipping 544 matching lines @@
     Token token = scan2(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
     Token comment = token.precedingComments;
     JUnitTestCase.assertNotNull(comment);
     JUnitTestCase.assertEquals(commentType, comment.type);
     JUnitTestCase.assertEquals(0, comment.offset);
     JUnitTestCase.assertEquals(source.length, comment.length);
     JUnitTestCase.assertEquals(source, comment.lexeme);
   }
-  
+
   /**
    * Assert that scanning the given source produces an error with the given code.
    * @param illegalCharacter
    * @param i
    * @param source the source to be scanned to produce the error
    */
   void assertError(ScannerErrorCode expectedError, int expectedOffset, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     scan(source, listener);
     listener.assertErrors([new AnalysisError.con2(null, expectedOffset, 1, expectedError, [(source.codeUnitAt(expectedOffset) as int)])]);
   }
-  
+
   /**
    * Assert that when scanned the given source contains a single keyword token with the same lexeme
    * as the original source.
    * @param source the source to be scanned
    */
   void assertKeywordToken(String source) {
     Token token = scan2(source);
     JUnitTestCase.assertNotNull(token);
     JUnitTestCase.assertEquals(TokenType.KEYWORD, token.type);
     JUnitTestCase.assertEquals(0, token.offset);
@@ skipping 18 matching lines @@
     scan(source, listener);
     listener.assertNoErrors();
     LineInfo info = listener.getLineInfo(new TestSource());
     JUnitTestCase.assertNotNull(info);
     for (AbstractScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
       JUnitTestCase.assertEquals(expectedLocation._lineNumber, location.lineNumber);
       JUnitTestCase.assertEquals(expectedLocation._columnNumber, location.columnNumber);
     }
   }
-  
+
   /**
    * Assert that the token scanned from the given source has the expected type.
    * @param expectedType the expected type of the token
    * @param source the source to be scanned to produce the actual token
    */
   Token assertToken(TokenType expectedType, String source) {
     Token originalToken = scan2(source);
     JUnitTestCase.assertNotNull(originalToken);
     JUnitTestCase.assertEquals(expectedType, originalToken.type);
     JUnitTestCase.assertEquals(0, originalToken.offset);
@@ skipping 12 matching lines @@
     }
     Token tokenWithSpaces = scan2(" ${source} ");
     JUnitTestCase.assertNotNull(tokenWithSpaces);
     JUnitTestCase.assertEquals(expectedType, tokenWithSpaces.type);
     JUnitTestCase.assertEquals(1, tokenWithSpaces.offset);
     JUnitTestCase.assertEquals(source.length, tokenWithSpaces.length);
     JUnitTestCase.assertEquals(source, tokenWithSpaces.lexeme);
     JUnitTestCase.assertEquals(TokenType.EOF, originalToken.next.type);
     return originalToken;
   }
-  
+
   /**
    * Assert that when scanned the given source contains a sequence of tokens identical to the given
    * tokens.
    * @param source the source to be scanned
    * @param expectedTokens the tokens that are expected to be in the source
    */
   void assertTokens(String source, List<Token> expectedTokens) {
     Token token = scan2(source);
     JUnitTestCase.assertNotNull(token);
     for (int i = 0; i < expectedTokens.length; i++) {
       Token expectedToken = expectedTokens[i];
       JUnitTestCase.assertEqualsMsg("Wrong type for token ${i}", expectedToken.type, token.type);
       JUnitTestCase.assertEqualsMsg("Wrong offset for token ${i}", expectedToken.offset, token.offset);
       JUnitTestCase.assertEqualsMsg("Wrong length for token ${i}", expectedToken.length, token.length);
       JUnitTestCase.assertEqualsMsg("Wrong lexeme for token ${i}", expectedToken.lexeme, token.lexeme);
       token = token.next;
       JUnitTestCase.assertNotNull(token);
     }
     JUnitTestCase.assertEquals(TokenType.EOF, token.type);
   }
   Token scan2(String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = scan(source, listener);
     listener.assertNoErrors();
     return token;
   }
 }
-
 /**
  * Instances of the class {@code ExpectedLocation} encode information about the expected location
  * of a given offset in source code.
  */
 class AbstractScannerTest_ExpectedLocation {
   int _offset = 0;
   int _lineNumber = 0;
   int _columnNumber = 0;
   AbstractScannerTest_ExpectedLocation(int offset, int lineNumber, int columnNumber) {
     this._offset = offset;
     this._lineNumber = lineNumber;
     this._columnNumber = columnNumber;
   }
 }
 main() {
   CharBufferScannerTest.dartSuite();
   KeywordStateTest.dartSuite();
   StringScannerTest.dartSuite();
   TokenTypeTest.dartSuite();
 }