Replace EngineTestCase.assertSize() with hasLength().

pkg/analyzer/test/generated/engine_test.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.engine_test;
 
 import 'dart:collection';
@@ skipping 274 matching lines @@
     Source source = _addSource("/test.dart", "library test;");
     _context.computeErrors(source);
     while (!_context.sourcesNeedingProcessing.isEmpty) {
       _context.performAnalysisTask();
     }
     // Adding the source as a changedSource should have no effect since
     // it is already overridden in the content cache.
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
     _context.applyChanges(changeSet);
-    EngineTestCase.assertSizeOfList(0, _context.sourcesNeedingProcessing);
+    expect(_context.sourcesNeedingProcessing, hasLength(0));
   }
 
   void test_applyChanges_remove() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source libA = _addSource(
         "/libA.dart",
         r'''
 library libA;
 import 'libB.dart';''');
     Source libB =
         _addSource("/libB.dart", "library libB;");
     LibraryElement libAElement = _context.computeLibraryElement(libA);
     List<LibraryElement> importedLibraries = libAElement.importedLibraries;
-    EngineTestCase.assertLength(2, importedLibraries);
+    expect(importedLibraries, hasLength(2));
     _context.computeErrors(libA);
     _context.computeErrors(libB);
-    EngineTestCase.assertSizeOfList(0, _context.sourcesNeedingProcessing);
+    expect(_context.sourcesNeedingProcessing, hasLength(0));
     _context.setContents(libB, null);
     _removeSource(libB);
     List<Source> sources = _context.sourcesNeedingProcessing;
-    EngineTestCase.assertSizeOfList(1, sources);
+    expect(sources, hasLength(1));
     expect(sources[0], same(libA));
     libAElement = _context.computeLibraryElement(libA);
     importedLibraries = libAElement.importedLibraries;
-    EngineTestCase.assertLength(1, importedLibraries);
+    expect(importedLibraries, hasLength(1));
   }
 
   void test_applyChanges_removeContainer() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source libA = _addSource(
         "/libA.dart",
         r'''
 library libA;
 import 'libB.dart';''');
     Source libB =
         _addSource("/libB.dart", "library libB;");
     _context.computeLibraryElement(libA);
     _context.computeErrors(libA);
     _context.computeErrors(libB);
-    EngineTestCase.assertSizeOfList(0, _context.sourcesNeedingProcessing);
+    expect(_context.sourcesNeedingProcessing, hasLength(0));
     ChangeSet changeSet = new ChangeSet();
     changeSet.removedContainer(
         new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB));
     _context.applyChanges(changeSet);
     List<Source> sources = _context.sourcesNeedingProcessing;
-    EngineTestCase.assertSizeOfList(1, sources);
+    expect(sources, hasLength(1));
     expect(sources[0], same(libA));
   }
 
   void test_computeDocumentationComment_block() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     String comment = "/** Comment */";
     Source source =
         _addSource("/test.dart", """
 $comment
@@ skipping 43 matching lines @@
     expect(libraryElement, isNotNull);
     ClassElement classElement = libraryElement.definingCompilationUnit.types[0];
     expect(libraryElement, isNotNull);
     String actual = _context.computeDocumentationComment(classElement);
     expect(actual, "/// line 1\n/// line 2\n/// line 3");
   }
 
   void test_computeErrors_dart_none() {
     Source source = _addSource("/lib.dart", "library lib;");
     List<AnalysisError> errors = _context.computeErrors(source);
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
   }
 
   void test_computeErrors_dart_part() {
     Source librarySource =
         _addSource("/lib.dart", "library lib; part 'part.dart';");
     Source partSource = _addSource("/part.dart", "part of 'lib';");
     _context.parseCompilationUnit(librarySource);
     List<AnalysisError> errors = _context.computeErrors(partSource);
     expect(errors, isNotNull);
     expect(errors.length > 0, isTrue);
   }
 
   void test_computeErrors_dart_some() {
     Source source = _addSource("/lib.dart", "library 'lib';");
     List<AnalysisError> errors = _context.computeErrors(source);
     expect(errors, isNotNull);
     expect(errors.length > 0, isTrue);
   }
 
   void test_computeErrors_html_none() {
     Source source = _addSource("/test.html", "<html></html>");
     List<AnalysisError> errors = _context.computeErrors(source);
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
   }
 
   void test_computeExportedLibraries_none() {
     Source source = _addSource("/test.dart", "library test;");
-    EngineTestCase.assertLength(0, _context.computeExportedLibraries(source));
+    expect(_context.computeExportedLibraries(source), hasLength(0));
   }
 
   void test_computeExportedLibraries_some() {
     //    addSource("/lib1.dart", "library lib1;");
     //    addSource("/lib2.dart", "library lib2;");
     Source source = _addSource(
         "/test.dart",
         "library test; export 'lib1.dart'; export 'lib2.dart';");
-    EngineTestCase.assertLength(2, _context.computeExportedLibraries(source));
+    expect(_context.computeExportedLibraries(source), hasLength(2));
   }
 
   void test_computeHtmlElement_nonHtml() {
     Source source = _addSource("/test.dart", "library test;");
     expect(_context.computeHtmlElement(source), isNull);
   }
 
   void test_computeHtmlElement_valid() {
     Source source = _addSource("/test.html", "<html></html>");
     HtmlElement element = _context.computeHtmlElement(source);
     expect(element, isNotNull);
     expect(_context.computeHtmlElement(source), same(element));
   }
 
   void test_computeImportedLibraries_none() {
     Source source = _addSource("/test.dart", "library test;");
-    EngineTestCase.assertLength(0, _context.computeImportedLibraries(source));
+    expect(_context.computeImportedLibraries(source), hasLength(0));
   }
 
   void test_computeImportedLibraries_some() {
     //    addSource("/lib1.dart", "library lib1;");
     //    addSource("/lib2.dart", "library lib2;");
     Source source = _addSource(
         "/test.dart",
         "library test; import 'lib1.dart'; import 'lib2.dart';");
-    EngineTestCase.assertLength(2, _context.computeImportedLibraries(source));
+    expect(_context.computeImportedLibraries(source), hasLength(2));
   }
 
   void test_computeKindOf_html() {
     Source source = _addSource("/test.html", "");
     expect(_context.computeKindOf(source), same(SourceKind.HTML));
   }
 
   void test_computeKindOf_library() {
     Source source = _addSource("/test.dart", "library lib;");
     expect(_context.computeKindOf(source), same(SourceKind.LIBRARY));
@@ skipping 182 matching lines @@
     LibraryElement library = _context.computeLibraryElement(source);
     ClassElement myEnum = library.definingCompilationUnit.getEnum('MyEnum');
     ElementLocation location = myEnum.location;
     Element element = _context.getElement(location);
     expect(element, same(myEnum));
   }
 
   void test_getErrors_dart_none() {
     Source source = _addSource("/lib.dart", "library lib;");
     List<AnalysisError> errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
     _context.computeErrors(source);
     errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
   }
 
   void test_getErrors_dart_some() {
     Source source = _addSource("/lib.dart", "library 'lib';");
     List<AnalysisError> errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
     _context.computeErrors(source);
     errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(1, errors);
+    expect(errors, hasLength(1));
   }
 
   void test_getErrors_html_none() {
     Source source = _addSource("/test.html", "<html></html>");
     List<AnalysisError> errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
     _context.computeErrors(source);
     errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
   }
 
   void test_getErrors_html_some() {
     Source source = _addSource(
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 </head></html>''');
     List<AnalysisError> errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(0, errors);
+    expect(errors, hasLength(0));
     _context.computeErrors(source);
     errors = _context.getErrors(source).errors;
-    EngineTestCase.assertLength(1, errors);
+    expect(errors, hasLength(1));
   }
 
   void test_getHtmlElement_dart() {
     Source source = _addSource("/test.dart", "");
     expect(_context.getHtmlElement(source), isNull);
     expect(_context.computeHtmlElement(source), isNull);
     expect(_context.getHtmlElement(source), isNull);
   }
 
   void test_getHtmlElement_html() {
@@ skipping 12 matching lines @@
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     Source librarySource = _addSource("/test.dart", "library lib;");
     Source secondHtmlSource = _addSource("/test.html", "<html></html>");
     _context.computeLibraryElement(librarySource);
     List<Source> result = _context.getHtmlFilesReferencing(secondHtmlSource);
-    EngineTestCase.assertLength(0, result);
+    expect(result, hasLength(0));
     _context.parseHtmlUnit(htmlSource);
     result = _context.getHtmlFilesReferencing(secondHtmlSource);
-    EngineTestCase.assertLength(0, result);
+    expect(result, hasLength(0));
   }
 
   void test_getHtmlFilesReferencing_library() {
     Source htmlSource = _addSource(
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     Source librarySource = _addSource("/test.dart", "library lib;");
     List<Source> result = _context.getHtmlFilesReferencing(librarySource);
-    EngineTestCase.assertLength(0, result);
+    expect(result, hasLength(0));
     _context.parseHtmlUnit(htmlSource);
     result = _context.getHtmlFilesReferencing(librarySource);
-    EngineTestCase.assertLength(1, result);
+    expect(result, hasLength(1));
     expect(result[0], htmlSource);
   }
 
   void test_getHtmlFilesReferencing_part() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source htmlSource = _addSource(
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     Source librarySource =
         _addSource("/test.dart", "library lib; part 'part.dart';");
     Source partSource = _addSource("/part.dart", "part of lib;");
     _context.computeLibraryElement(librarySource);
     List<Source> result = _context.getHtmlFilesReferencing(partSource);
-    EngineTestCase.assertLength(0, result);
+    expect(result, hasLength(0));
     _context.parseHtmlUnit(htmlSource);
     result = _context.getHtmlFilesReferencing(partSource);
-    EngineTestCase.assertLength(1, result);
+    expect(result, hasLength(1));
     expect(result[0], htmlSource);
   }
 
   void test_getHtmlSources() {
     List<Source> sources = _context.htmlSources;
-    EngineTestCase.assertLength(0, sources);
+    expect(sources, hasLength(0));
     Source source = _addSource("/test.html", "");
     _context.computeKindOf(source);
     sources = _context.htmlSources;
-    EngineTestCase.assertLength(1, sources);
+    expect(sources, hasLength(1));
     expect(sources[0], source);
   }
 
   void test_getKindOf_html() {
     Source source = _addSource("/test.html", "");
     expect(_context.getKindOf(source), same(SourceKind.HTML));
   }
 
   void test_getKindOf_library() {
     Source source = _addSource("/test.dart", "library lib;");
@@ skipping 11 matching lines @@
 
   void test_getKindOf_unknown() {
     Source source = _addSource("/test.css", "");
     expect(_context.getKindOf(source), same(SourceKind.UNKNOWN));
   }
 
   void test_getLaunchableClientLibrarySources() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     List<Source> sources = _context.launchableClientLibrarySources;
-    EngineTestCase.assertLength(0, sources);
+    expect(sources, hasLength(0));
     Source source = _addSource(
         "/test.dart",
         r'''
 import 'dart:html';
 main() {}''');
     _context.computeLibraryElement(source);
     sources = _context.launchableClientLibrarySources;
-    EngineTestCase.assertLength(1, sources);
+    expect(sources, hasLength(1));
   }
 
   void test_getLaunchableServerLibrarySources() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     List<Source> sources = _context.launchableServerLibrarySources;
-    EngineTestCase.assertLength(0, sources);
+    expect(sources, hasLength(0));
     Source source = _addSource("/test.dart", "main() {}");
     _context.computeLibraryElement(source);
     sources = _context.launchableServerLibrarySources;
-    EngineTestCase.assertLength(1, sources);
+    expect(sources, hasLength(1));
   }
 
   void test_getLibrariesContaining() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source librarySource = _addSource(
         "/lib.dart",
         r'''
 library lib;
 part 'part.dart';''');
     Source partSource = _addSource("/part.dart", "part of lib;");
     _context.computeLibraryElement(librarySource);
     List<Source> result = _context.getLibrariesContaining(librarySource);
-    EngineTestCase.assertLength(1, result);
+    expect(result, hasLength(1));
     expect(result[0], librarySource);
     result = _context.getLibrariesContaining(partSource);
-    EngineTestCase.assertLength(1, result);
+    expect(result, hasLength(1));
     expect(result[0], librarySource);
   }
 
   void test_getLibrariesDependingOn() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source libASource = _addSource("/libA.dart", "library libA;");
     _addSource("/libB.dart", "library libB;");
     Source lib1Source = _addSource(
         "/lib1.dart",
@@ skipping 20 matching lines @@
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     Source librarySource = _addSource("/test.dart", "library lib;");
     _context.computeLibraryElement(librarySource);
     _context.parseHtmlUnit(htmlSource);
     List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource);
-    EngineTestCase.assertLength(1, result);
+    expect(result, hasLength(1));
     expect(result[0], librarySource);
   }
 
   void test_getLibrariesReferencedFromHtml_no() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source htmlSource = _addSource(
         "/test.html",
         r'''
 <html><head>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     _addSource("/test.dart", "library lib;");
     _context.parseHtmlUnit(htmlSource);
     List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource);
-    EngineTestCase.assertLength(0, result);
+    expect(result, hasLength(0));
   }
 
   void test_getLibraryElement() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source source = _addSource("/test.dart", "library lib;");
     LibraryElement element = _context.getLibraryElement(source);
     expect(element, isNull);
     _context.computeLibraryElement(source);
     element = _context.getLibraryElement(source);
     expect(element, isNotNull);
   }
 
   void test_getLibrarySources() {
     List<Source> sources = _context.librarySources;
     int originalLength = sources.length;
     Source source = _addSource("/test.dart", "library lib;");
     _context.computeKindOf(source);
     sources = _context.librarySources;
-    EngineTestCase.assertLength(originalLength + 1, sources);
+    expect(sources, hasLength(originalLength + 1));
     for (Source returnedSource in sources) {
       if (returnedSource == source) {
         return;
       }
     }
     fail("The added source was not in the list of library sources");
   }
 
   void test_getLineInfo() {
     Source source = _addSource(
@@ skipping 32 matching lines @@
     expect(namespace, isNotNull);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         namespace.get("A"));
   }
 
   void test_getRefactoringUnsafeSources() {
     // not sources initially
     List<Source> sources = _context.refactoringUnsafeSources;
-    EngineTestCase.assertLength(0, sources);
+    expect(sources, hasLength(0));
     // add new source, unresolved
     Source source = _addSource("/test.dart", "library lib;");
     sources = _context.refactoringUnsafeSources;
-    EngineTestCase.assertLength(1, sources);
+    expect(sources, hasLength(1));
     expect(sources[0], source);
     // resolve source
     _context.computeLibraryElement(source);
     sources = _context.refactoringUnsafeSources;
-    EngineTestCase.assertLength(0, sources);
+    expect(sources, hasLength(0));
   }
 
   void test_getResolvedCompilationUnit_library() {
     _context = AnalysisContextFactory.contextWithCore();
     _sourceFactory = _context.sourceFactory;
     Source source = _addSource("/lib.dart", "library libb;");
     LibraryElement library = _context.computeLibraryElement(source);
     expect(_context.getResolvedCompilationUnit(source, library), isNotNull);
     _context.setContents(source, "library lib;");
     expect(_context.getResolvedCompilationUnit(source, library), isNull);
@@ skipping 110 matching lines @@
 
   void test_parseCompilationUnit_html() {
     Source source = _addSource("/test.html", "<html></html>");
     expect(_context.parseCompilationUnit(source), isNull);
   }
 
   void test_parseCompilationUnit_noErrors() {
     Source source = _addSource("/lib.dart", "library lib;");
     CompilationUnit compilationUnit = _context.parseCompilationUnit(source);
     expect(compilationUnit, isNotNull);
-    EngineTestCase.assertLength(0, _context.getErrors(source).errors);
+    expect(_context.getErrors(source).errors, hasLength(0));
   }
 
   void test_parseCompilationUnit_nonExistentSource() {
     Source source =
         new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
     try {
       _context.parseCompilationUnit(source);
       fail("Expected AnalysisException because file does not exist");
     } on AnalysisException catch (exception) {
       // Expected result
@@ skipping 137 matching lines @@
     _context.setContents(
         partSource,
         r'''
 part of lib;
 void g() { f(null); }''');
     expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull, reason: "library changed 2");
     expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull, reason: "part changed 2");
     _analyzeAll_assertFinished();
     expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNotNull, reason: "library resolved 2");
     expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNotNull, reason: "part resolved 2");
-    EngineTestCase.assertLength(0, _context.getErrors(libSource).errors);
-    EngineTestCase.assertLength(0, _context.getErrors(partSource).errors);
+    expect(_context.getErrors(libSource).errors, hasLength(0));
+    expect(_context.getErrors(partSource).errors, hasLength(0));
   }
 
   /**
    * https://code.google.com/p/dart/issues/detail?id=12424
    */
   void test_performAnalysisTask_changePartContents_makeItNotPart() {
     Source libSource = _addSource(
         "/lib.dart",
         r'''
 library lib;
 part 'part.dart';
 void f(x) {}''');
     Source partSource = _addSource(
         "/part.dart",
         r'''
 part of lib;
 void g() { f(null); }''');
     _analyzeAll_assertFinished();
-    EngineTestCase.assertLength(0, _context.getErrors(libSource).errors);
-    EngineTestCase.assertLength(0, _context.getErrors(partSource).errors);
+    expect(_context.getErrors(libSource).errors, hasLength(0));
+    expect(_context.getErrors(partSource).errors, hasLength(0));
     // Remove 'part' directive, which should make "f(null)" an error.
     _context.setContents(
         partSource,
         r'''
 //part of lib;
 void g() { f(null); }''');
     _analyzeAll_assertFinished();
     expect(_context.getErrors(libSource).errors.length != 0, isTrue);
   }
 
@@ skipping 713 matching lines @@
     expect(entry.getState(DartEntry.TOKEN_STREAM), same(CacheState.INVALID));
     expect(entry.getStateInLibrary(DartEntry.HINTS, librarySource), same(CacheState.INVALID));
     expect(entry.getStateInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource), same(CacheState.INVALID));
     expect(entry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), same(CacheState.INVALID));
     expect(entry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource), same(CacheState.INVALID));
   }
 
   void test_getAllErrors() {
     Source source = new TestSource();
     DartEntry entry = new DartEntry();
-    EngineTestCase.assertLength(0, entry.allErrors);
+    expect(entry.allErrors, hasLength(0));
     entry.setValue(
         DartEntry.SCAN_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
                 ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
                 [])]);
     entry.setValue(
         DartEntry.PARSE_ERRORS,
         <AnalysisError>[
@@ skipping 11 matching lines @@
         source,
         <AnalysisError>[
             new AnalysisError.con1(
                 source,
                 StaticWarningCode.CASE_BLOCK_NOT_TERMINATED,
                 [])]);
     entry.setValueInLibrary(
         DartEntry.HINTS,
         source,
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
-    EngineTestCase.assertLength(5, entry.allErrors);
+    expect(entry.allErrors, hasLength(5));
   }
 
   void test_getResolvableCompilationUnit_none() {
     DartEntry entry = new DartEntry();
     expect(entry.resolvableCompilationUnit, isNull);
   }
 
   void test_getResolvableCompilationUnit_parsed_accessed() {
     Source librarySource = new TestSource("/lib.dart");
     String importUri = "/f1.dart";
@@ skipping 108 matching lines @@
       fail("Expected IllegalArgumentException for VERIFICATION_ERRORS");
     } on ArgumentError catch (exception) {
       // Expected
     }
   }
 
   void test_getValue_containingLibraries() {
     Source testSource = new TestSource();
     DartEntry entry = new DartEntry();
     List<Source> value = entry.containingLibraries;
-    EngineTestCase.assertLength(0, value);
+    expect(value, hasLength(0));
     entry.addContainingLibrary(testSource);
     value = entry.containingLibraries;
-    EngineTestCase.assertLength(1, value);
+    expect(value, hasLength(1));
     expect(value[0], testSource);
     entry.removeContainingLibrary(testSource);
     value = entry.containingLibraries;
-    EngineTestCase.assertLength(0, value);
+    expect(value, hasLength(0));
   }
 
   void test_getValueInLibrary_invalid_element() {
     DartEntry entry = new DartEntry();
     try {
       entry.getValueInLibrary(DartEntry.ELEMENT, new TestSource());
       fail("Expected IllegalArgumentException for ELEMENT");
     } on ArgumentError catch (exception) {
       // Expected
     }
@@ skipping 811 matching lines @@
   GenerateDartErrorsTaskTestTV_perform(this.libraryElement, this.source);
   @override
   bool visitGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.libraryElement, same(libraryElement));
     expect(task.source, same(source));
     List<AnalysisError> errors = task.errors;
-    EngineTestCase.assertLength(1, errors);
+    expect(errors, hasLength(1));
     return true;
   }
 }
 
 
 class GenerateDartErrorsTaskTestTV_perform_validateDirectives extends
     TestTaskVisitor<bool> {
   LibraryElement libraryElement;
   Source source;
   GenerateDartErrorsTaskTestTV_perform_validateDirectives(this.libraryElement,
       this.source);
   @override
   bool visitGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.libraryElement, same(libraryElement));
     expect(task.source, same(source));
     List<AnalysisError> errors = task.errors;
-    EngineTestCase.assertLength(1, errors);
+    expect(errors, hasLength(1));
     expect(errors[0].errorCode, same(CompileTimeErrorCode.URI_DOES_NOT_EXIST));
     return true;
   }
 }
 
 class GenerateDartHintsTaskTest extends EngineTestCase {
   void test_accept() {
     GenerateDartHintsTask task = new GenerateDartHintsTask(null, null, null);
     expect(task.accept(new GenerateDartHintsTaskTestTV_accept()), isTrue);
   }
@@ skipping 65 matching lines @@
   Source partSource;
   GenerateDartHintsTaskTestTV_perform(this.librarySource, this.partSource);
   @override
   bool visitGenerateDartHintsTask(GenerateDartHintsTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.libraryElement, isNotNull);
     HashMap<Source, List<AnalysisError>> hintMap = task.hintMap;
-    EngineTestCase.assertSizeOfMap(2, hintMap);
-    EngineTestCase.assertLength(1, hintMap[librarySource]);
-    EngineTestCase.assertLength(0, hintMap[partSource]);
+    expect(hintMap, hasLength(2));
+    expect(hintMap[librarySource], hasLength(1));
+    expect(hintMap[partSource], hasLength(0));
     return true;
   }
 }
 
 
 class GetContentTaskTest extends EngineTestCase {
   void test_accept() {
     Source source = new TestSource('/test.dart', '');
     GetContentTask task = new GetContentTask(null, source);
     expect(task.accept(new GetContentTaskTestTV_accept()), isTrue);
@@ skipping 77 matching lines @@
   }
 
   void test_creation() {
     HtmlEntry entry = new HtmlEntry();
     expect(entry, isNotNull);
   }
 
   void test_getAllErrors() {
     Source source = new TestSource();
     HtmlEntry entry = new HtmlEntry();
-    EngineTestCase.assertLength(0, entry.allErrors);
+    expect(entry.allErrors, hasLength(0));
     entry.setValue(
         HtmlEntry.PARSE_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, ParserErrorCode.EXPECTED_TOKEN, [";"])]);
     entry.setValue(
         HtmlEntry.RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, HtmlWarningCode.INVALID_URI, ["-"])]);
     entry.setValue(
         HtmlEntry.ANGULAR_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, AngularCode.INVALID_REPEAT_SYNTAX, ["-"])]);
     entry.setValue(
         HtmlEntry.POLYMER_BUILD_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.POLYMER_RESOLUTION_ERRORS,
         <AnalysisError>[
             new AnalysisError.con1(source, PolymerCode.INVALID_ATTRIBUTE_NAME, ["-"])]);
     entry.setValue(
         HtmlEntry.HINTS,
         <AnalysisError>[new AnalysisError.con1(source, HintCode.DEAD_CODE, [])]);
-    EngineTestCase.assertLength(6, entry.allErrors);
+    expect(entry.allErrors, hasLength(6));
   }
 
   void test_invalidateAllResolutionInformation() {
     HtmlEntry entry = _entryWithValidState();
     entry.invalidateAllResolutionInformation(false);
     expect(entry.getState(HtmlEntry.ANGULAR_APPLICATION), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.ANGULAR_COMPONENT), same(CacheState.VALID));
     expect(entry.getState(HtmlEntry.ANGULAR_ENTRY), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.ANGULAR_ERRORS), same(CacheState.INVALID));
     expect(entry.getState(HtmlEntry.POLYMER_BUILD_ERRORS), same(CacheState.INVALID));
@@ skipping 1230 matching lines @@
     expect(task.accept(new ParseDartTaskTestTV_accept()), isTrue);
   }
 
   void test_getCompilationUnit() {
     ParseDartTask task = new ParseDartTask(null, null, null, null);
     expect(task.compilationUnit, isNull);
   }
 
   void test_getErrors() {
     ParseDartTask task = new ParseDartTask(null, null, null, null);
-    EngineTestCase.assertLength(0, task.errors);
+    expect(task.errors, hasLength(0));
   }
 
   void test_getException() {
     ParseDartTask task = new ParseDartTask(null, null, null, null);
     expect(task.exception, isNull);
   }
 
   void test_getSource() {
     Source source = new TestSource('/test.dart');
     ParseDartTask task = new ParseDartTask(null, source, null, null);
@@ skipping 112 matching lines @@
   InternalAnalysisContext context;
   Source source;
   ParseDartTaskTestTV_perform_library(this.context, this.source);
   @override
   Object visitParseDartTask(ParseDartTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.compilationUnit, isNotNull);
-    EngineTestCase.assertLength(1, task.errors);
+    expect(task.errors, hasLength(1));
     expect(task.source, same(source));
     expect(task.hasNonPartOfDirective, isTrue);
     expect(task.hasPartOfDirective, isFalse);
     return null;
   }
 }
 
 
 class ParseDartTaskTestTV_perform_part extends TestTaskVisitor<Object> {
   InternalAnalysisContext context;
   Source source;
   ParseDartTaskTestTV_perform_part(this.context, this.source);
   @override
   Object visitParseDartTask(ParseDartTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.compilationUnit, isNotNull);
-    EngineTestCase.assertLength(0, task.errors);
+    expect(task.errors, hasLength(0));
     expect(task.source, same(source));
     expect(task.hasNonPartOfDirective, isFalse);
     expect(task.hasPartOfDirective, isTrue);
     return null;
   }
 }
 
 
 class ParseDartTaskTestTV_perform_validateDirectives extends
     TestTaskVisitor<Object> {
@@ skipping 63 matching lines @@
     expect(task.htmlUnit, isNull);
   }
 
   void test_getLineInfo() {
     ParseHtmlTask task = new ParseHtmlTask(null, null, "");
     expect(task.lineInfo, isNull);
   }
 
   void test_getReferencedLibraries() {
     ParseHtmlTask task = new ParseHtmlTask(null, null, "");
-    EngineTestCase.assertLength(0, task.referencedLibraries);
+    expect(task.referencedLibraries, hasLength(0));
   }
 
   void test_getSource() {
     Source source = new TestSource('/test.dart');
     ParseHtmlTask task = new ParseHtmlTask(null, source, "");
     expect(task.source, same(source));
   }
 
   void test_perform_embedded_source() {
     String contents = r'''
 <html>
 <head>
   <script type='application/dart'>
     void buttonPressed() {}
   </script>
 </head>
 <body>
 </body>
 </html>''';
     TestLogger testLogger = new TestLogger();
     ParseHtmlTask task = parseContents(contents, testLogger);
-    EngineTestCase.assertLength(0, task.referencedLibraries);
+    expect(task.referencedLibraries, hasLength(0));
     expect(testLogger.errorCount, 0);
     expect(testLogger.infoCount, 0);
   }
 
   void test_perform_empty_source_reference() {
     String contents = r'''
 <html>
 <head>
   <script type='application/dart' src=''/>
 </head>
 <body>
 </body>
 </html>''';
     TestLogger testLogger = new TestLogger();
     ParseHtmlTask task = parseContents(contents, testLogger);
-    EngineTestCase.assertLength(0, task.referencedLibraries);
+    expect(task.referencedLibraries, hasLength(0));
     expect(testLogger.errorCount, 0);
     expect(testLogger.infoCount, 0);
   }
 
   void test_perform_invalid_source_reference() {
     String contents = r'''
 <html>
 <head>
   <script type='application/dart' src='an;invalid:[]uri'/>
 </head>
 <body>
 </body>
 </html>''';
     TestLogger testLogger = new TestLogger();
     ParseHtmlTask task = parseContents(contents, testLogger);
-    EngineTestCase.assertLength(0, task.referencedLibraries);
+    expect(task.referencedLibraries, hasLength(0));
     expect(testLogger.errorCount, 0);
     expect(testLogger.infoCount, 0);
   }
 
   void test_perform_non_existing_source_reference() {
     String contents = r'''
 <html>
 <head>
   <script type='application/dart' src='does/not/exist.dart'/>
 </head>
 <body>
 </body>
 </html>''';
     TestLogger testLogger = new TestLogger();
     ParseHtmlTask task = parseSource(
         new ParseHtmlTaskTest_non_existing_source(contents),
         contents,
         testLogger);
-    EngineTestCase.assertLength(0, task.referencedLibraries);
+    expect(task.referencedLibraries, hasLength(0));
     expect(testLogger.errorCount, 0);
     expect(testLogger.infoCount, 0);
   }
 
   void test_perform_referenced_source() {
     // TODO(scheglov) this test fails because we put into cache TestSource
     // test.dart (and actually should test.html), but resolve
     // src='test.dart' as a FileBasedSource
     // We need to switch to a virtual file system and use it everywhere.
 //    String contents = EngineTestCase.createSource([
@@ skipping 274 matching lines @@
     expect(task.element, isNull);
   }
 
   void test_getException() {
     ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null);
     expect(task.exception, isNull);
   }
 
   void test_getResolutionErrors() {
     ResolveHtmlTask task = new ResolveHtmlTask(null, null, 0, null);
-    EngineTestCase.assertLength(0, task.resolutionErrors);
+    expect(task.resolutionErrors, hasLength(0));
   }
 
   void test_getSource() {
     Source source = new TestSource('test.dart', '');
     ResolveHtmlTask task = new ResolveHtmlTask(null, source, 0, null);
     expect(task.source, same(source));
   }
 
   void test_perform_exception() {
     Source source = new TestSource();
@@ skipping 50 matching lines @@
   int modificationStamp;
   Source source;
   ResolveHtmlTaskTestTV_perform_valid(this.modificationStamp, this.source);
   @override
   Object visitResolveHtmlTask(ResolveHtmlTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.element, isNotNull);
-    EngineTestCase.assertLength(1, task.resolutionErrors);
+    expect(task.resolutionErrors, hasLength(1));
     expect(task.source, same(source));
     return null;
   }
 }
 
 
 class ResolveHtmlTaskTestTV_perform_valid_2 extends TestTaskVisitor<Object> {
   @override
   Object visitParseHtmlTask(ParseHtmlTask task) => null;
 }
 
 
 class ScanDartTaskTest extends EngineTestCase {
   void test_accept() {
     ScanDartTask task = new ScanDartTask(null, null, null);
     expect(task.accept(new ScanDartTaskTestTV_accept()), isTrue);
   }
 
   void test_getErrors() {
     ScanDartTask task = new ScanDartTask(null, null, null);
-    EngineTestCase.assertLength(0, task.errors);
+    expect(task.errors, hasLength(0));
   }
 
   void test_getException() {
     ScanDartTask task = new ScanDartTask(null, null, null);
     expect(task.exception, isNull);
   }
 
   void test_getLineInfo() {
     ScanDartTask task = new ScanDartTask(null, null, null);
     expect(task.lineInfo, isNull);
@@ skipping 27 matching lines @@
   InternalAnalysisContext context;
   Source source;
   ScanDartTaskTestTV_perform_valid(this.context, this.source);
   @override
   bool visitScanDartTask(ScanDartTask task) {
     CaughtException exception = task.exception;
     if (exception != null) {
       throw exception;
     }
     expect(task.tokenStream, isNotNull);
-    EngineTestCase.assertLength(0, task.errors);
+    expect(task.errors, hasLength(0));
     expect(task.lineInfo, isNotNull);
     expect(task.source, same(source));
     return true;
   }
 }
 
 
 class SdkCachePartitionTest extends EngineTestCase {
   void test_contains_false() {
     SdkCachePartition partition = new SdkCachePartition(null, 8);
@@ skipping 1215 matching lines @@
   }
 }
 
 
 class _UniversalCachePartitionTest_test_setMaxCacheSize implements
     CacheRetentionPolicy {
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) =>
       RetentionPriority.LOW;
 }