Inline JUnitTestCase 'assert' methods.

pkg/analyzer/test/generated/resolver_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.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
-import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
-import 'package:unittest/unittest.dart' as _ut;
+import 'package:unittest/unittest.dart';
 import 'test_support.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import '../reflective_tests.dart';
 
 
 /**
  * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
@@ skipping 226 matching lines @@
       return sourceFactory.dartSdk.context.getModificationStamp(source);
     }
     return super.getModificationStamp(source);
   }
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     AnalysisOptions currentOptions = analysisOptions;
     bool needsRecompute = currentOptions.analyzeFunctionBodies != options.analyzeFunctionBodies || currentOptions.generateSdkErrors != options.generateSdkErrors || currentOptions.enableAsync != options.enableAsync || currentOptions.enableDeferredLoading != options.enableDeferredLoading || currentOptions.enableEnum != options.enableEnum || currentOptions.dart2jsHint != options.dart2jsHint || (currentOptions.hint && !options.hint) || currentOptions.preserveComments != options.preserveComments;
     if (needsRecompute) {
-      JUnitTestCase.fail("Cannot set options that cause the sources to be reanalyzed in a test context");
+      fail("Cannot set options that cause the sources to be reanalyzed in a test context");
     }
     super.analysisOptions = options;
   }
 
   /**
    * Set the analysis options, even if they would force re-analysis. This method should only be
    * invoked before the fake SDK is initialized.
    *
    * @param options the analysis options to be set
    */
@@ skipping 54 matching lines @@
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     delta.setAnalysisLevel(source3, AnalysisLevel.NONE);
     List<Source> addedSources = delta.addedSources;
     EngineTestCase.assertLength(2, addedSources);
     EngineTestCase.assertContains(addedSources, [source1, source2]);
   }
 
   void test_getAnalysisLevels() {
     AnalysisDelta delta = new AnalysisDelta();
-    JUnitTestCase.assertEquals(0, delta.analysisLevels.length);
+    expect(delta.analysisLevels.length, 0);
   }
 
   void test_setAnalysisLevel() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source1, AnalysisLevel.ALL);
     delta.setAnalysisLevel(source2, AnalysisLevel.ERRORS);
     Map<Source, AnalysisLevel> levels = delta.analysisLevels;
-    JUnitTestCase.assertEquals(2, levels.length);
-    JUnitTestCase.assertEquals(AnalysisLevel.ALL, levels[source1]);
-    JUnitTestCase.assertEquals(AnalysisLevel.ERRORS, levels[source2]);
+    expect(levels.length, 2);
+    expect(levels[source1], AnalysisLevel.ALL);
+    expect(levels[source2], AnalysisLevel.ERRORS);
   }
 
   void test_toString() {
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(new TestSource(), AnalysisLevel.ALL);
     String result = delta.toString();
-    JUnitTestCase.assertNotNull(result);
-    JUnitTestCase.assertTrue(result.length > 0);
+    expect(result, isNotNull);
+    expect(result.length > 0, isTrue);
   }
 }
 
 class ChangeSetTest extends EngineTestCase {
   void test_changedContent() {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedContent(source, content);
     EngineTestCase.assertSizeOfList(0, changeSet.addedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.changedSources);
     Map<Source, String> map = changeSet.changedContents;
     EngineTestCase.assertSizeOfMap(1, map);
-    JUnitTestCase.assertSame(content, map[source]);
+    expect(map[source], same(content));
     EngineTestCase.assertSizeOfMap(0, changeSet.changedRanges);
     EngineTestCase.assertSizeOfList(0, changeSet.deletedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.removedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.removedContainers);
   }
 
   void test_changedRange() {
     TestSource source = new TestSource();
     String content = "";
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedRange(source, content, 1, 2, 3);
     EngineTestCase.assertSizeOfList(0, changeSet.addedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.changedSources);
     EngineTestCase.assertSizeOfMap(0, changeSet.changedContents);
     Map<Source, ChangeSet_ContentChange> map = changeSet.changedRanges;
     EngineTestCase.assertSizeOfMap(1, map);
     ChangeSet_ContentChange change = map[source];
-    JUnitTestCase.assertNotNull(change);
-    JUnitTestCase.assertEquals(content, change.contents);
-    JUnitTestCase.assertEquals(1, change.offset);
-    JUnitTestCase.assertEquals(2, change.oldLength);
-    JUnitTestCase.assertEquals(3, change.newLength);
+    expect(change, isNotNull);
+    expect(change.contents, content);
+    expect(change.offset, 1);
+    expect(change.oldLength, 2);
+    expect(change.newLength, 3);
     EngineTestCase.assertSizeOfList(0, changeSet.deletedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.removedSources);
     EngineTestCase.assertSizeOfList(0, changeSet.removedContainers);
   }
 
   void test_toString() {
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(new TestSource());
     changeSet.changedSource(new TestSource());
     changeSet.changedContent(new TestSource(), "");
     changeSet.changedRange(new TestSource(), "", 0, 0, 0);
     changeSet.deletedSource(new TestSource());
     changeSet.removedSource(new TestSource());
     changeSet.removedContainer(new SourceContainer_ChangeSetTest_test_toString());
-    JUnitTestCase.assertNotNull(changeSet.toString());
+    expect(changeSet.toString(), isNotNull);
   }
 }
 
 class CheckedModeCompileTimeErrorCodeTest extends ResolverTestCase {
   void test_fieldFormalParameterAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B extends A (and hence is a
     // subtype of A).
     Source source = addSource(r'''
 class A {
@@ skipping 636 matching lines @@
   }
 
   void _assertCompilationUnitMatches(bool expectMatch, String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
     AnalysisContext context = analysisContext;
     context.setContents(source, newContent);
     CompilationUnit newUnit = context.parseCompilationUnit(source);
     DeclarationMatcher matcher = new DeclarationMatcher();
-    JUnitTestCase.assertEquals(expectMatch, matcher.matches(newUnit, oldUnit.element));
+    expect(matcher.matches(newUnit, oldUnit.element), expectMatch);
   }
 
   void _assertMethodMatches(bool expectMatch, String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
     MethodElement element = _getFirstMethod(oldUnit).element as MethodElement;
     AnalysisContext context = analysisContext;
     context.setContents(source, newContent);
     CompilationUnit newUnit = context.parseCompilationUnit(source);
     MethodDeclaration newMethod = _getFirstMethod(newUnit);
     DeclarationMatcher matcher = new DeclarationMatcher();
-    JUnitTestCase.assertEquals(expectMatch, matcher.matches(newMethod, element));
+    expect(matcher.matches(newMethod, element), expectMatch);
   }
 
   MethodDeclaration _getFirstMethod(CompilationUnit unit) {
     ClassDeclaration classNode = unit.declarations[0] as ClassDeclaration;
     return classNode.members[0] as MethodDeclaration;
   }
 }
 
 class DirectoryBasedDartSdk_AnalysisContextFactory_initContextWithCore extends DirectoryBasedDartSdk {
   DirectoryBasedDartSdk_AnalysisContextFactory_initContextWithCore(JavaFile arg0) : super(arg0);
@@ skipping 40 matching lines @@
    * The resolver visitor that maintains the state for the resolver.
    */
   ResolverVisitor _visitor;
 
   /**
    * The resolver being used to resolve the test cases.
    */
   ElementResolver _resolver;
 
   void fail_visitExportDirective_combinators() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     // Need to set up the exported library so that the identifier can be resolved
     ExportDirective directive = AstFactory.exportDirective2(null, [AstFactory.hideCombinator2(["A"])]);
     _resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionExpressionInvocation() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_noPrefix() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     // Need to set up the imported library so that the identifier can be resolved
     ImportDirective directive = AstFactory.importDirective3(null, null, [AstFactory.showCombinator2(["A"])]);
     _resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitImportDirective_combinators_prefix() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     // Need to set up the imported library so that the identifiers can be resolved
     String prefixName = "p";
     _definingLibrary.imports = <ImportElement> [ElementFactory.importFor(null, ElementFactory.prefix(prefixName), [])];
     ImportDirective directive = AstFactory.importDirective3(null, prefixName, [
         AstFactory.showCombinator2(["A"]),
         AstFactory.hideCombinator2(["B"])]);
     _resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void fail_visitRedirectingConstructorInvocation() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _resolver = _createResolver();
   }
 
@@ skipping 19 matching lines @@
     // class D extends C {}
     //
     ClassElementImpl classD = ElementFactory.classElement("D", classC.type, []);
     //
     // D a;
     // a[i];
     //
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classD.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
-    JUnitTestCase.assertSame(operator, _resolveIndexExpression(expression, []));
+    expect(_resolveIndexExpression(expression, []), same(operator));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
     InterfaceType intType = _typeProvider.intType;
     SimpleIdentifier leftHandSide = AstFactory.identifier3("a");
     leftHandSide.staticType = intType;
     AssignmentExpression assignment = AstFactory.assignmentExpression(leftHandSide, TokenType.PLUS_EQ, AstFactory.integer(1));
     _resolveNode(assignment, []);
-    JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.staticElement);
+    expect(assignment.staticElement, same(getMethod(_typeProvider.numType, "+")));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_simple() {
     AssignmentExpression expression = AstFactory.assignmentExpression(AstFactory.identifier3("x"), TokenType.EQ, AstFactory.integer(0));
     _resolveNode(expression, []);
-    JUnitTestCase.assertNull(expression.staticElement);
+    expect(expression.staticElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression() {
     // num i;
     // var j;
     // i + j
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = numType;
     BinaryExpression expression = AstFactory.binaryExpression(left, TokenType.PLUS, AstFactory.identifier3("j"));
     _resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
-    JUnitTestCase.assertNull(expression.propagatedElement);
+    expect(expression.staticElement, getMethod(numType, "+"));
+    expect(expression.propagatedElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_propagatedElement() {
     // var i = 1;
     // var j;
     // i + j
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.propagatedType = numType;
     BinaryExpression expression = AstFactory.binaryExpression(left, TokenType.PLUS, AstFactory.identifier3("j"));
     _resolveNode(expression, []);
-    JUnitTestCase.assertNull(expression.staticElement);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.propagatedElement);
+    expect(expression.staticElement, isNull);
+    expect(expression.propagatedElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(AstFactory.identifier3(label), false, false);
     BreakStatement statement = AstFactory.breakStatement2(label);
-    JUnitTestCase.assertSame(labelElement, _resolveBreak(statement, labelElement));
+    expect(_resolveBreak(statement, labelElement), same(labelElement));
     _listener.assertNoErrors();
   }
 
   void test_visitBreakStatement_withoutLabel() {
     BreakStatement statement = AstFactory.breakStatement();
     _resolveStatement(statement, null);
     _listener.assertNoErrors();
   }
 
   void test_visitConstructorName_named() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String constructorName = "a";
     ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
     _resolveNode(name, []);
-    JUnitTestCase.assertSame(constructor, name.staticElement);
+    expect(name.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitConstructorName_unnamed() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String constructorName = null;
     ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
     _resolveNode(name, []);
-    JUnitTestCase.assertSame(constructor, name.staticElement);
+    expect(name.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(AstFactory.identifier3(label), false, false);
     ContinueStatement statement = AstFactory.continueStatement(label);
-    JUnitTestCase.assertSame(labelElement, _resolveContinue(statement, labelElement));
+    expect(_resolveContinue(statement, labelElement), same(labelElement));
     _listener.assertNoErrors();
   }
 
   void test_visitContinueStatement_withoutLabel() {
     ContinueStatement statement = AstFactory.continueStatement();
     _resolveStatement(statement, null);
     _listener.assertNoErrors();
   }
 
   void test_visitExportDirective_noCombinators() {
     ExportDirective directive = AstFactory.exportDirective2(null, []);
     directive.element = ElementFactory.exportFor(ElementFactory.library(_definingLibrary.context, "lib"), []);
     _resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter() {
     String fieldName = "f";
     InterfaceType intType = _typeProvider.intType;
     FieldElementImpl fieldElement = ElementFactory.fieldElement(fieldName, false, false, false, intType);
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.fields = <FieldElement> [fieldElement];
     FieldFormalParameter parameter = AstFactory.fieldFormalParameter2(fieldName);
     FieldFormalParameterElementImpl parameterElement = ElementFactory.fieldFormalParameter(parameter.identifier);
     parameterElement.field = fieldElement;
     parameterElement.type = intType;
     parameter.identifier.staticElement = parameterElement;
     _resolveInClass(parameter, classA);
-    JUnitTestCase.assertSame(intType, parameter.element.type);
+    expect(parameter.element.type, same(intType));
   }
 
   void test_visitImportDirective_noCombinators_noPrefix() {
     ImportDirective directive = AstFactory.importDirective3(null, null, []);
     directive.element = ElementFactory.importFor(ElementFactory.library(_definingLibrary.context, "lib"), null, []);
     _resolveNode(directive, []);
     _listener.assertNoErrors();
   }
 
   void test_visitImportDirective_noCombinators_prefix() {
@@ skipping 11 matching lines @@
     ImportDirective directive = AstFactory.importDirective3(null, null, [combinator]);
     LibraryElementImpl library = ElementFactory.library(_definingLibrary.context, "lib");
     TopLevelVariableElementImpl varA = ElementFactory.topLevelVariableElement2("A");
     TopLevelVariableElementImpl varB = ElementFactory.topLevelVariableElement2("B");
     TopLevelVariableElementImpl varC = ElementFactory.topLevelVariableElement2("C");
     CompilationUnitElementImpl unit = library.definingCompilationUnit as CompilationUnitElementImpl;
     unit.accessors = <PropertyAccessorElement> [varA.getter, varA.setter, varB.getter, varC.setter];
     unit.topLevelVariables = <TopLevelVariableElement> [varA, varB, varC];
     directive.element = ElementFactory.importFor(library, null, []);
     _resolveNode(directive, []);
-    JUnitTestCase.assertSame(varA, combinator.shownNames[0].staticElement);
-    JUnitTestCase.assertSame(varB, combinator.shownNames[1].staticElement);
-    JUnitTestCase.assertSame(varC, combinator.shownNames[2].staticElement);
+    expect(combinator.shownNames[0].staticElement, same(varA));
+    expect(combinator.shownNames[1].staticElement, same(varB));
+    expect(combinator.shownNames[2].staticElement, same(varC));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_get() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType intType = _typeProvider.intType;
     MethodElement getter = ElementFactory.methodElement("[]", intType, [intType]);
     classA.methods = <MethodElement> [getter];
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
-    JUnitTestCase.assertSame(getter, _resolveIndexExpression(expression, []));
+    expect(_resolveIndexExpression(expression, []), same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_set() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType intType = _typeProvider.intType;
     MethodElement setter = ElementFactory.methodElement("[]=", intType, [intType]);
     classA.methods = <MethodElement> [setter];
     SimpleIdentifier array = AstFactory.identifier3("a");
     array.staticType = classA.type;
     IndexExpression expression = AstFactory.indexExpression(array, AstFactory.identifier3("i"));
     AstFactory.assignmentExpression(expression, TokenType.EQ, AstFactory.integer(0));
-    JUnitTestCase.assertSame(setter, _resolveIndexExpression(expression, []));
+    expect(_resolveIndexExpression(expression, []), same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String constructorName = "a";
     ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, []);
     _resolveNode(creation, []);
-    JUnitTestCase.assertSame(constructor, creation.staticElement);
+    expect(creation.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String constructorName = null;
     ConstructorElement constructor = ElementFactory.constructorElement2(classA, constructorName, []);
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, []);
     _resolveNode(creation, []);
-    JUnitTestCase.assertSame(constructor, creation.staticElement);
+    expect(creation.staticElement, same(constructor));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed_namedParameter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String constructorName = null;
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(classA, constructorName, []);
     String parameterName = "a";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     constructor.parameters = <ParameterElement> [parameter];
     classA.constructors = <ConstructorElement> [constructor];
     ConstructorName name = AstFactory.constructorName(AstFactory.typeName(classA, []), constructorName);
     name.staticElement = constructor;
     InstanceCreationExpression creation = AstFactory.instanceCreationExpression(Keyword.NEW, name, [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveNode(creation, []);
-    JUnitTestCase.assertSame(constructor, creation.staticElement);
-    JUnitTestCase.assertSame(parameter, (creation.argumentList.arguments[0] as NamedExpression).name.label.staticElement);
+    expect(creation.staticElement, same(constructor));
+    expect((creation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = numType;
     String methodName = "abs";
     MethodInvocation invocation = AstFactory.methodInvocation(left, methodName, []);
     _resolveNode(invocation, []);
-    JUnitTestCase.assertSame(getMethod(numType, methodName), invocation.methodName.staticElement);
+    expect(invocation.methodName.staticElement, same(getMethod(numType, methodName)));
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_namedParameter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     String parameterName = "p";
     MethodElementImpl method = ElementFactory.methodElement(methodName, null, []);
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     method.parameters = <ParameterElement> [parameter];
     classA.methods = <MethodElement> [method];
     SimpleIdentifier left = AstFactory.identifier3("i");
     left.staticType = classA.type;
     MethodInvocation invocation = AstFactory.methodInvocation(left, methodName, [AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveNode(invocation, []);
-    JUnitTestCase.assertSame(method, invocation.methodName.staticElement);
-    JUnitTestCase.assertSame(parameter, (invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement);
+    expect(invocation.methodName.staticElement, same(method));
+    expect((invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PostfixExpression expression = AstFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
     _resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
+    expect(expression.staticElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_dynamic() {
     DartType dynamicType = _typeProvider.dynamicType;
     SimpleIdentifier target = AstFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = dynamicType;
     target.staticElement = variable;
     target.staticType = dynamicType;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3("b"));
     _resolveNode(identifier, []);
-    JUnitTestCase.assertNull(identifier.staticElement);
-    JUnitTestCase.assertNull(identifier.identifier.staticElement);
+    expect(identifier.staticElement, isNull);
+    expect(identifier.identifier.staticElement, isNull);
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_nonDynamic() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = AstFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = classA.type;
     target.staticElement = variable;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(getterName));
     _resolveNode(identifier, []);
-    JUnitTestCase.assertSame(getter, identifier.staticElement);
-    JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
+    expect(identifier.staticElement, same(getter));
+    expect(identifier.identifier.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
     // prepare "A.m"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     // resolve
     _resolveNode(identifier, []);
-    JUnitTestCase.assertSame(getter, identifier.staticElement);
-    JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
+    expect(identifier.staticElement, same(getter));
+    expect(identifier.identifier.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     // set accessors
     String propName = "m";
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setter];
     // set methods
     MethodElement method = ElementFactory.methodElement("m", _typeProvider.intType, []);
     classA.methods = <MethodElement> [method];
     // prepare "A.m"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     AstFactory.assignmentExpression(identifier, TokenType.EQ, AstFactory.nullLiteral());
     // resolve
     _resolveNode(identifier, []);
-    JUnitTestCase.assertSame(method, identifier.staticElement);
-    JUnitTestCase.assertSame(method, identifier.identifier.staticElement);
+    expect(identifier.staticElement, same(method));
+    expect(identifier.identifier.staticElement, same(method));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_staticClassMember_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     // set accessors
     String propName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
     PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter, setter];
     // prepare "A.b = null"
     SimpleIdentifier target = AstFactory.identifier3("A");
     target.staticElement = classA;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = AstFactory.identifier(target, AstFactory.identifier3(propName));
     AstFactory.assignmentExpression(identifier, TokenType.EQ, AstFactory.nullLiteral());
     // resolve
     _resolveNode(identifier, []);
-    JUnitTestCase.assertSame(setter, identifier.staticElement);
-    JUnitTestCase.assertSame(setter, identifier.identifier.staticElement);
+    expect(identifier.staticElement, same(setter));
+    expect(identifier.identifier.staticElement, same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = AstFactory.identifier3("i");
     operand.staticType = numType;
     PrefixExpression expression = AstFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
     _resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
+    expect(expression.staticElement, getMethod(numType, "+"));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter_identifier() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = AstFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
     _resolveNode(access, []);
-    JUnitTestCase.assertSame(getter, access.propertyName.staticElement);
+    expect(access.propertyName.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_getter_super() {
     //
     // class A {
     //  int get b;
     // }
     // class B {
     //   ... super.m ...
     // }
     //
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SuperExpression target = AstFactory.superExpression();
     target.staticType = ElementFactory.classElement("B", classA.type, []).type;
     PropertyAccess access = AstFactory.propertyAccess2(target, getterName);
     AstFactory.methodDeclaration2(null, null, null, null, AstFactory.identifier3("m"), AstFactory.formalParameterList([]), AstFactory.expressionFunctionBody(access));
     _resolveNode(access, []);
-    JUnitTestCase.assertSame(getter, access.propertyName.staticElement);
+    expect(access.propertyName.staticElement, same(getter));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_setter_this() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "b";
     PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setter];
     ThisExpression target = AstFactory.thisExpression();
     target.staticType = classA.type;
     PropertyAccess access = AstFactory.propertyAccess2(target, setterName);
     AstFactory.assignmentExpression(access, TokenType.EQ, AstFactory.integer(0));
     _resolveNode(access, []);
-    JUnitTestCase.assertSame(setter, access.propertyName.staticElement);
+    expect(access.propertyName.staticElement, same(setter));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_classScope() {
     InterfaceType doubleType = _typeProvider.doubleType;
     String fieldName = "NAN";
     SimpleIdentifier node = AstFactory.identifier3(fieldName);
     _resolveInClass(node, doubleType.element);
-    JUnitTestCase.assertEquals(getGetter(doubleType, fieldName), node.staticElement);
+    expect(node.staticElement, getGetter(doubleType, fieldName));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_dynamic() {
     SimpleIdentifier node = AstFactory.identifier3("dynamic");
     _resolveIdentifier(node, []);
-    JUnitTestCase.assertSame(_typeProvider.dynamicType.element, node.staticElement);
-    JUnitTestCase.assertSame(_typeProvider.typeType, node.staticType);
+    expect(node.staticElement, same(_typeProvider.dynamicType.element));
+    expect(node.staticType, same(_typeProvider.typeType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_lexicalScope() {
     SimpleIdentifier node = AstFactory.identifier3("i");
     VariableElementImpl element = ElementFactory.localVariableElement(node);
-    JUnitTestCase.assertSame(element, _resolveIdentifier(node, [element]));
+    expect(_resolveIdentifier(node, [element]), same(element));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_lexicalScope_field_setter() {
     InterfaceType intType = _typeProvider.intType;
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String fieldName = "a";
     FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType);
     classA.fields = <FieldElement> [field];
     classA.accessors = <PropertyAccessorElement> [field.getter, field.setter];
     SimpleIdentifier node = AstFactory.identifier3(fieldName);
     AstFactory.assignmentExpression(node, TokenType.EQ, AstFactory.integer(0));
     _resolveInClass(node, classA);
     Element element = node.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyAccessorElement, PropertyAccessorElement, element);
-    JUnitTestCase.assertTrue((element as PropertyAccessorElement).isSetter);
+    expect((element as PropertyAccessorElement).isSetter, isTrue);
     _listener.assertNoErrors();
   }
 
   void test_visitSuperConstructorInvocation() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null, []);
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null, []);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = AstFactory.superConstructorInvocation([]);
     _resolveInClass(invocation, subclass);
-    JUnitTestCase.assertEquals(superConstructor, invocation.staticElement);
+    expect(invocation.staticElement, superConstructor);
     _listener.assertNoErrors();
   }
 
   void test_visitSuperConstructorInvocation_namedParameter() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement2(superclass, null, []);
     String parameterName = "p";
     ParameterElement parameter = ElementFactory.namedParameter(parameterName);
     superConstructor.parameters = <ParameterElement> [parameter];
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement2(subclass, null, []);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = AstFactory.superConstructorInvocation([AstFactory.namedExpression2(parameterName, AstFactory.integer(0))]);
     _resolveInClass(invocation, subclass);
-    JUnitTestCase.assertEquals(superConstructor, invocation.staticElement);
-    JUnitTestCase.assertSame(parameter, (invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement);
+    expect(invocation.staticElement, superConstructor);
+    expect((invocation.argumentList.arguments[0] as NamedExpression).name.label.staticElement, same(parameter));
     _listener.assertNoErrors();
   }
 
   /**
    * Create the resolver used by the tests.
    *
    * @return the resolver that was created
    */
   ElementResolver _createResolver() {
     AnalysisContextImpl context = new AnalysisContextImpl();
@@ skipping 208 matching lines @@
   }
 
   void test_enclosingElement_invalidLocalFunction() {
     Source source = addSource(r'''
 class C {
   C() {
     int get x => 0;
   }
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     var unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     var types = unit.types;
-    JUnitTestCase.assertNotNull(types);
+    expect(types, isNotNull);
     EngineTestCase.assertSizeOfList(1, types);
     var type = types[0];
-    JUnitTestCase.assertNotNull(type);
+    expect(type, isNotNull);
     var constructors = type.constructors;
-    JUnitTestCase.assertNotNull(constructors);
+    expect(constructors, isNotNull);
     EngineTestCase.assertSizeOfList(1, constructors);
     ConstructorElement constructor = constructors[0];
-    JUnitTestCase.assertNotNull(constructor);
+    expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
-    JUnitTestCase.assertNotNull(functions);
+    expect(functions, isNotNull);
     EngineTestCase.assertSizeOfList(1, functions);
-    JUnitTestCase.assertEquals(constructor, functions[0].enclosingElement);
+    expect(functions[0].enclosingElement, constructor);
     assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
     Source source = addSource(r'''
 f() {
   try {
     var one = 1;
@@ skipping 73 matching lines @@
   n(void f(int i)) {}
 }''');
     resolve(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_argumentTypeNotAssignable_message() {
     // The implementation of HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE assumes that
     // StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE has the same message.
-    JUnitTestCase.assertEquals(HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message);
+    expect(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message, HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message);
   }
 
   void test_argumentTypeNotAssignable_type() {
     Source source = addSource(r'''
 m() {
   var i = '';
   n(i);
 }
 n(int i) {}''');
     resolve(source);
@@ skipping 733 matching lines @@
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_message() {
     // The implementation of HintCode.INVALID_ASSIGNMENT assumes that
     // StaticTypeWarningCode.INVALID_ASSIGNMENT has the same message.
-    JUnitTestCase.assertEquals(HintCode.INVALID_ASSIGNMENT.message, StaticTypeWarningCode.INVALID_ASSIGNMENT.message);
+    expect(StaticTypeWarningCode.INVALID_ASSIGNMENT.message, HintCode.INVALID_ASSIGNMENT.message);
   }
 
   void test_invalidAssignment_staticVariable() {
     Source source = addSource(r'''
 class A {
   static int x;
 }
 f(var y) {
   if(y is String) {
     A.x = y;
@@ skipping 128 matching lines @@
     return a.m;
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that UNDEFINED_SETTER in
     // StaticTypeWarningCode and StaticWarningCode are the same, this verifies that assumption.
-    JUnitTestCase.assertEquals(StaticTypeWarningCode.UNDEFINED_GETTER.message, StaticWarningCode.UNDEFINED_GETTER.message);
+    expect(StaticWarningCode.UNDEFINED_GETTER.message, StaticTypeWarningCode.UNDEFINED_GETTER.message);
   }
 
   void test_undefinedMethod() {
     Source source = addSource(r'''
 f() {
   var a = 'str';
   a.notAMethodOnString();
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
@@ skipping 115 matching lines @@
     a.m = 0;
   }
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that UNDEFINED_SETTER in
     // StaticTypeWarningCode and StaticWarningCode are the same, this verifies that assumption.
-    JUnitTestCase.assertEquals(StaticTypeWarningCode.UNDEFINED_SETTER.message, StaticWarningCode.UNDEFINED_SETTER.message);
+    expect(StaticWarningCode.UNDEFINED_SETTER.message, StaticTypeWarningCode.UNDEFINED_SETTER.message);
   }
 
   void test_unnecessaryCast_type_supertype() {
     Source source = addSource(r'''
 m(int i) {
   var b = i as Object;
 }''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_CAST]);
     verify([source]);
@@ skipping 209 matching lines @@
     return a + a;
   }
 }''');
     BlockFunctionBody body = method.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     BinaryExpression expression = statement.expression as BinaryExpression;
     SimpleIdentifier left = expression.leftOperand as SimpleIdentifier;
     Element leftElement = left.staticElement;
     SimpleIdentifier right = expression.rightOperand as SimpleIdentifier;
     Element rightElement = right.staticElement;
-    JUnitTestCase.assertNotNull(leftElement);
-    JUnitTestCase.assertSame(leftElement, rightElement);
+    expect(leftElement, isNotNull);
+    expect(rightElement, same(leftElement));
   }
 
   MethodDeclaration _resolveMethod(String content) {
     Source source = addSource(content);
     LibraryElement library = resolve(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classNode = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration method = classNode.members[0] as MethodDeclaration;
     method.body.accept(new ResolutionEraser());
     GatheringErrorListener errorListener = new GatheringErrorListener();
@@ skipping 35 matching lines @@
   void test_getMapOfMembersInheritedFromClasses_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapB.size);
-    JUnitTestCase.assertNull(mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject);
+    expect(mapB.get(getterName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_implicitExtends() {
     // class A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    expect(mapA.size, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_extends() {
     // class A { int g(); }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.supertype = classA.type;
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_implements() {
     // class A { int g(); }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapB.size);
-    JUnitTestCase.assertNull(mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject);
+    expect(mapB.get(methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromClasses_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_extends() {
     // class A { int get g; }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_implements() {
     // class A { int get g; }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_accessor_with() {
     // class A { int get g; }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_implicitExtends() {
     // class A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    expect(mapA.size, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_getter_method() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classI1.methods = <MethodElement> [methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement getter = ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement> [getter];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI2.type, classI1.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertNull(mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElement methodM1 = ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     MethodElement methodM2 = ElementFactory.methodElement(methodName, null, [_typeProvider.stringType]);
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertNull(mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_method_getter() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classI1.methods = <MethodElement> [methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement getter = ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement> [getter];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertNull(mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
     // class I1 { dynamic m(int, [int]); }
     // class I2 { dynamic m(int, int, int); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
@@ skipping 14 matching lines @@
     parameter4.type = _typeProvider.intType;
     parameter4.parameterKind = ParameterKind.REQUIRED;
     ParameterElementImpl parameter5 = new ParameterElementImpl.forNode(AstFactory.identifier3("a5"));
     parameter5.type = _typeProvider.intType;
     parameter5.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement> [parameter3, parameter4, parameter5];
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertNull(mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_str_int() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElement methodM1 = ElementFactory.methodElement(methodName, null, [_typeProvider.stringType]);
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     MethodElement methodM2 = ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI2.type, classI1.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertNull(mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapA.get(methodName), isNull);
     _assertErrors(classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_extends() {
     // class A { int g(); }
     // class B extends A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_implements() {
     // class A { int g(); }
     // class B implements A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_method_with() {
     // class A { int g(); }
     // class B extends Object with A {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
     MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
-    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
+    expect(mapA.size, _numOfMembersInObject);
+    expect(mapB.size, _numOfMembersInObject + 1);
+    expect(mapB.get(methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_differentNames() {
     // class I1 { int m1(); }
     // class I2 { int m2(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName1 = "m1";
     MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType, []);
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     String methodName2 = "m2";
     MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType, []);
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 2, mapA.size);
-    JUnitTestCase.assertSame(methodM1, mapA.get(methodName1));
-    JUnitTestCase.assertSame(methodM2, mapA.get(methodName2));
+    expect(mapA.size, _numOfMembersInObject + 2);
+    expect(mapA.get(methodName1), same(methodM1));
+    expect(mapA.get(methodName2), same(methodM2));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_getters() {
     // class I1 { int get g; }
     // class I2 { num get g; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement> [getter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement getter2 = ElementFactory.getterElement(accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement> [getter2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
+    expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(accessorName, false, _typeProvider.dynamicType);
-    JUnitTestCase.assertEquals(syntheticAccessor.type, mapA.get(accessorName).type);
+    expect(mapA.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_methods() {
     // class I1 { dynamic m(int); }
     // class I2 { dynamic m(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElementImpl methodM1 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.REQUIRED;
     methodM1.parameters = <ParameterElement> [parameter1];
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
     ParameterElementImpl parameter2 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter2.type = _typeProvider.numType;
     parameter2.parameterKind = ParameterKind.REQUIRED;
     methodM2.parameters = <ParameterElement> [parameter2];
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
+    expect(mapA.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
-    JUnitTestCase.assertEquals(syntheticMethod.type, mapA.get(methodName).type);
+    expect(mapA.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_setters() {
     // class I1 { set s(int); }
     // class I2 { set s(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement> [setter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement setter2 = ElementFactory.setterElement(accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement> [setter2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
+    expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory.setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
-    JUnitTestCase.assertEquals(syntheticAccessor.type, mapA.get("$accessorName=").type);
+    expect(mapA.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_getters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { A get g; }
     // class I2 { B get g; }
     // class I3 { C get g; }
     // class D implements I1, I2, I3 {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(accessorName, false, classA.type);
     classI1.accessors = <PropertyAccessorElement> [getter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement getter2 = ElementFactory.getterElement(accessorName, false, classB.type);
     classI2.accessors = <PropertyAccessorElement> [getter2];
     ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
     PropertyAccessorElement getter3 = ElementFactory.getterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement> [getter3];
     ClassElementImpl classD = ElementFactory.classElement2("D", []);
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapD.size);
+    expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(accessorName, false, _typeProvider.dynamicType);
-    JUnitTestCase.assertEquals(syntheticAccessor.type, mapD.get(accessorName).type);
+    expect(mapD.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_methods() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { dynamic m(A a); }
     // class I2 { dynamic m(B b); }
     // class I3 { dynamic m(C c); }
@@ skipping 19 matching lines @@
     ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
     MethodElementImpl methodM3 = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, []);
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter3.type = classC.type;
     parameter3.parameterKind = ParameterKind.REQUIRED;
     methodM3.parameters = <ParameterElement> [parameter3];
     classI3.methods = <MethodElement> [methodM3];
     ClassElementImpl classD = ElementFactory.classElement2("D", []);
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapD.size);
+    expect(mapD.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
-    JUnitTestCase.assertEquals(syntheticMethod.type, mapD.get(methodName).type);
+    expect(mapD.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_setters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { set s(A); }
     // class I2 { set s(B); }
     // class I3 { set s(C); }
     // class D implements I1, I2, I3 {}
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(accessorName, false, classA.type);
     classI1.accessors = <PropertyAccessorElement> [setter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     PropertyAccessorElement setter2 = ElementFactory.setterElement(accessorName, false, classB.type);
     classI2.accessors = <PropertyAccessorElement> [setter2];
     ClassElementImpl classI3 = ElementFactory.classElement2("I3", []);
     PropertyAccessorElement setter3 = ElementFactory.setterElement(accessorName, false, classC.type);
     classI3.accessors = <PropertyAccessorElement> [setter3];
     ClassElementImpl classD = ElementFactory.classElement2("D", []);
     classD.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapD = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapD.size);
+    expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory.setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
-    JUnitTestCase.assertEquals(syntheticAccessor.type, mapD.get("$accessorName=").type);
+    expect(mapD.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_2_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
     MethodElement methodM1 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     MethodElementImpl methodM2 = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     ParameterElementImpl parameter1 = new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM2.parameters = <ParameterElement> [parameter1];
     classI2.methods = <MethodElement> [methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
-    JUnitTestCase.assertSame(methodM2, mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject + 1);
+    expect(mapA.get(methodName), same(methodM2));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_3_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class I3 { int m([int, int]); }
     // class A implements I1, I2, I3 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName = "m";
@@ skipping 12 matching lines @@
     parameter2.type = _typeProvider.intType;
     parameter2.parameterKind = ParameterKind.POSITIONAL;
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a3"));
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM3.parameters = <ParameterElement> [parameter2, parameter3];
     classI3.methods = <MethodElement> [methodM3];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
-    JUnitTestCase.assertSame(methodM3, mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject + 1);
+    expect(mapA.get(methodName), same(methodM3));
     _assertNoErrors(classA);
   }
 
   void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_4_methods() {
     // class I1 { int m(); }
     // class I2 { int m(); }
     // class I3 { int m([int]); }
     // class I4 { int m([int, int]); }
     // class A implements I1, I2, I3, I4 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
@@ skipping 16 matching lines @@
     parameter2.type = _typeProvider.intType;
     parameter2.parameterKind = ParameterKind.POSITIONAL;
     ParameterElementImpl parameter3 = new ParameterElementImpl.forNode(AstFactory.identifier3("a3"));
     parameter3.type = _typeProvider.intType;
     parameter3.parameterKind = ParameterKind.POSITIONAL;
     methodM4.parameters = <ParameterElement> [parameter2, parameter3];
     classI4.methods = <MethodElement> [methodM4];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI1.type, classI2.type, classI3.type, classI4.type];
     MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapA.size);
-    JUnitTestCase.assertSame(methodM4, mapA.get(methodName));
+    expect(mapA.size, _numOfMembersInObject + 1);
+    expect(mapA.get(methodName), same(methodM4));
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_interface_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(getterG, _inheritanceManager.lookupInheritance(classB, getterName));
+    expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(methodM, _inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(setterS, _inheritanceManager.lookupInheritance(classB, "$setterName="));
+    expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interface_staticMember() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interfaces_infiniteLoop() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classA, "name"));
+    expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_interfaces_infiniteLoop2() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classA.interfaces = <InterfaceType> [classB.type];
     classB.interfaces = <InterfaceType> [classA.type];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classA, "name"));
+    expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_interfaces_union2() {
     ClassElementImpl classI1 = ElementFactory.classElement2("I1", []);
     String methodName1 = "m1";
     MethodElement methodM1 = ElementFactory.methodElement(methodName1, _typeProvider.intType, []);
     classI1.methods = <MethodElement> [methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2", []);
     String methodName2 = "m2";
     MethodElement methodM2 = ElementFactory.methodElement(methodName2, _typeProvider.intType, []);
     classI2.methods = <MethodElement> [methodM2];
     classI2.interfaces = <InterfaceType> [classI1.type];
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.interfaces = <InterfaceType> [classI2.type];
-    JUnitTestCase.assertSame(methodM1, _inheritanceManager.lookupInheritance(classA, methodName1));
-    JUnitTestCase.assertSame(methodM2, _inheritanceManager.lookupInheritance(classA, methodName2));
+    expect(_inheritanceManager.lookupInheritance(classA, methodName1), same(methodM1));
+    expect(_inheritanceManager.lookupInheritance(classA, methodName2), same(methodM2));
     _assertNoErrors(classI1);
     _assertNoErrors(classI2);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_mixin_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(getterG, _inheritanceManager.lookupInheritance(classB, getterName));
+    expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(methodM, _inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    JUnitTestCase.assertSame(setterS, _inheritanceManager.lookupInheritance(classB, "$setterName="));
+    expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_mixin_staticMember() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_noMember() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classA, "a"));
+    expect(_inheritanceManager.lookupInheritance(classA, "a"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_superclass_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    JUnitTestCase.assertSame(getterG, _inheritanceManager.lookupInheritance(classB, getterName));
+    expect(_inheritanceManager.lookupInheritance(classB, getterName), same(getterG));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_infiniteLoop() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.supertype = classA.type;
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classA, "name"));
+    expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupInheritance_superclass_infiniteLoop2() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classA.supertype = classB.type;
     classB.supertype = classA.type;
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classA, "name"));
+    expect(_inheritanceManager.lookupInheritance(classA, "name"), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    JUnitTestCase.assertSame(methodM, _inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), same(methodM));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    JUnitTestCase.assertSame(setterS, _inheritanceManager.lookupInheritance(classB, "$setterName="));
+    expect(_inheritanceManager.lookupInheritance(classB, "$setterName="), same(setterS));
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupInheritance_superclass_staticMember() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    JUnitTestCase.assertNull(_inheritanceManager.lookupInheritance(classB, methodName));
+    expect(_inheritanceManager.lookupInheritance(classB, methodName), isNull);
     _assertNoErrors(classA);
     _assertNoErrors(classB);
   }
 
   void test_lookupMember_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    JUnitTestCase.assertSame(getterG, _inheritanceManager.lookupMember(classA, getterName));
+    expect(_inheritanceManager.lookupMember(classA, getterName), same(getterG));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_getter_static() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, true, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupMember(classA, getterName));
+    expect(_inheritanceManager.lookupMember(classA, getterName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_method() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
-    JUnitTestCase.assertSame(methodM, _inheritanceManager.lookupMember(classA, methodName));
+    expect(_inheritanceManager.lookupMember(classA, methodName), same(methodM));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_method_static() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     (methodM as MethodElementImpl).static = true;
     classA.methods = <MethodElement> [methodM];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupMember(classA, methodName));
+    expect(_inheritanceManager.lookupMember(classA, methodName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_noMember() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
-    JUnitTestCase.assertNull(_inheritanceManager.lookupMember(classA, "a"));
+    expect(_inheritanceManager.lookupMember(classA, "a"), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_setter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
-    JUnitTestCase.assertSame(setterS, _inheritanceManager.lookupMember(classA, "$setterName="));
+    expect(_inheritanceManager.lookupMember(classA, "$setterName="), same(setterS));
     _assertNoErrors(classA);
   }
 
   void test_lookupMember_setter_static() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String setterName = "s";
     PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, true, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [setterS];
-    JUnitTestCase.assertNull(_inheritanceManager.lookupMember(classA, setterName));
+    expect(_inheritanceManager.lookupMember(classA, setterName), isNull);
     _assertNoErrors(classA);
   }
 
   void test_lookupOverrides_noParentClasses() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElementImpl methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     EngineTestCase.assertSizeOfList(0, _inheritanceManager.lookupOverrides(classA, methodName));
     _assertNoErrors(classA);
@@ skipping 98 matching lines @@
 library lib;
 part 'first.dart';
 part 'second.dart';''');
     addSource("/first.dart", r'''
 part of lib;
 int get V => 0;''');
     addSource("/second.dart", r'''
 part of lib;
 void set V(int v) {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
-    JUnitTestCase.assertNotNull(element);
+    expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
     EngineTestCase.assertLength(1, firstAccessors);
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
     EngineTestCase.assertLength(1, secondAccessors);
-    JUnitTestCase.assertSame(firstAccessors[0].variable, secondAccessors[0].variable);
+    expect(secondAccessors[0].variable, same(firstAccessors[0].variable));
   }
 
   void test_empty() {
     Source librarySource = addSource("/lib.dart", "library lib;");
     LibraryElement element = _buildLibrary(librarySource, []);
-    JUnitTestCase.assertNotNull(element);
-    JUnitTestCase.assertEquals("lib", element.name);
-    JUnitTestCase.assertNull(element.entryPoint);
+    expect(element, isNotNull);
+    expect(element.name, "lib");
+    expect(element.entryPoint, isNull);
     EngineTestCase.assertLength(0, element.importedLibraries);
     EngineTestCase.assertLength(0, element.imports);
-    JUnitTestCase.assertSame(element, element.library);
+    expect(element.library, same(element));
     EngineTestCase.assertLength(0, element.prefixes);
     EngineTestCase.assertLength(0, element.parts);
     CompilationUnitElement unit = element.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
-    JUnitTestCase.assertEquals("lib.dart", unit.name);
-    JUnitTestCase.assertEquals(element, unit.library);
+    expect(unit, isNotNull);
+    expect(unit.name, "lib.dart");
+    expect(unit.library, element);
     EngineTestCase.assertLength(0, unit.accessors);
     EngineTestCase.assertLength(0, unit.functions);
     EngineTestCase.assertLength(0, unit.functionTypeAliases);
     EngineTestCase.assertLength(0, unit.types);
     EngineTestCase.assertLength(0, unit.topLevelVariables);
   }
 
   void test_missingLibraryDirectiveWithPart() {
     addSource("/a.dart", "part of lib;");
     Source librarySource = addSource("/lib.dart", "part 'a.dart';");
     LibraryElement element = _buildLibrary(librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
-    JUnitTestCase.assertNotNull(element);
+    expect(element, isNotNull);
   }
 
   void test_missingPartOfDirective() {
     addSource("/a.dart", "class A {}");
     Source librarySource = addSource("/lib.dart", r'''
 library lib;
 
 part 'a.dart';''');
     LibraryElement element = _buildLibrary(librarySource, [CompileTimeErrorCode.PART_OF_NON_PART]);
-    JUnitTestCase.assertNotNull(element);
+    expect(element, isNotNull);
   }
 
   void test_multipleFiles() {
     Source librarySource = addSource("/lib.dart", r'''
 library lib;
 part 'first.dart';
 part 'second.dart';
 
 class A {}''');
     addSource("/first.dart", r'''
 part of lib;
 class B {}''');
     addSource("/second.dart", r'''
 part of lib;
 class C {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
-    JUnitTestCase.assertNotNull(element);
+    expect(element, isNotNull);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     _assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       _assertTypes(sourcedUnits[0], ["B"]);
       _assertTypes(sourcedUnits[1], ["C"]);
     } else {
       _assertTypes(sourcedUnits[0], ["C"]);
       _assertTypes(sourcedUnits[1], ["B"]);
     }
   }
 
   void test_singleFile() {
     Source librarySource = addSource("/lib.dart", r'''
 library lib;
 
 class A {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
-    JUnitTestCase.assertNotNull(element);
+    expect(element, isNotNull);
     _assertTypes(element.definingCompilationUnit, ["A"]);
   }
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(FileUtilities2.createFile(filePath));
     _context.setContents(source, contents);
     return source;
   }
 
   @override
   void tearDown() {
     _context = null;
     super.tearDown();
   }
 
   /**
    * Ensure that there are elements representing all of the types in the given array of type names.
    *
    * @param unit the compilation unit containing the types
    * @param typeNames the names of the types that should be found
    */
   void _assertTypes(CompilationUnitElement unit, List<String> typeNames) {
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> types = unit.types;
     EngineTestCase.assertLength(typeNames.length, types);
     for (ClassElement type in types) {
-      JUnitTestCase.assertNotNull(type);
+      expect(type, isNotNull);
       String actualTypeName = type.displayName;
       bool wasExpected = false;
       for (String expectedTypeName in typeNames) {
         if (expectedTypeName == actualTypeName) {
           wasExpected = true;
         }
       }
       if (!wasExpected) {
-        JUnitTestCase.fail("Found unexpected type $actualTypeName");
+        fail("Found unexpected type $actualTypeName");
       }
     }
   }
 
   /**
    * Build the element model for the library whose defining compilation unit has the given source.
    *
    * @param librarySource the source of the defining compilation unit for the library
    * @param expectedErrorCodes the errors that are expected to be found while building the element
    *          model
@@ skipping 27 matching lines @@
     (importedLibrary1.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeA, typeB1];
     ImportElementImpl import1 = ElementFactory.importFor(importedLibrary1, null, []);
     LibraryElement importedLibrary2 = createTestLibrary(context, "imported2", []);
     (importedLibrary2.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeB2, typeC];
     ImportElementImpl import2 = ElementFactory.importFor(importedLibrary2, null, []);
     LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
     importingLibrary.imports = <ImportElement> [import1, import2];
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
-      JUnitTestCase.assertEquals(typeA, scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary));
+      expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary), typeA);
       errorListener.assertNoErrors();
-      JUnitTestCase.assertEquals(typeC, scope.lookup(AstFactory.identifier3(typeNameC), importingLibrary));
+      expect(scope.lookup(AstFactory.identifier3(typeNameC), importingLibrary), typeC);
       errorListener.assertNoErrors();
       Element element = scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary);
       errorListener.assertErrorsWithCodes([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, element);
       List<Element> conflictingElements = (element as MultiplyDefinedElement).conflictingElements;
       EngineTestCase.assertLength(2, conflictingElements);
       if (identical(conflictingElements[0], typeB1)) {
-        JUnitTestCase.assertSame(typeB2, conflictingElements[1]);
+        expect(conflictingElements[1], same(typeB2));
       } else if (identical(conflictingElements[0], typeB2)) {
-        JUnitTestCase.assertSame(typeB1, conflictingElements[1]);
+        expect(conflictingElements[1], same(typeB1));
       } else {
-        JUnitTestCase.assertSame(typeB1, conflictingElements[0]);
+        expect(conflictingElements[0], same(typeB1));
       }
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       Identifier identifier = AstFactory.identifier3(typeNameB);
       AstFactory.methodDeclaration(null, AstFactory.typeName3(identifier, []), null, null, AstFactory.identifier3("foo"), null);
       Element element = scope.lookup(identifier, importingLibrary);
       errorListener.assertErrorsWithCodes([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf((obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, element);
@@ skipping 12 matching lines @@
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary(context, "importing", []);
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(importedType, scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary));
+    expect(scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary), importedType);
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(errorListener, scope.errorListener);
+    expect(scope.errorListener, errorListener);
   }
 
   void test_nonConflictingImports_fromSdk() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "List";
     ClassElement type = ElementFactory.classElement2(typeName, []);
     LibraryElement importedLibrary = createTestLibrary(context, "lib", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [type];
     ImportElementImpl importCore = ElementFactory.importFor(context.getLibraryElement(context.sourceFactory.forUri("dart:core")), null, []);
     ImportElementImpl importLib = ElementFactory.importFor(importedLibrary, null, []);
     LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
     importingLibrary.imports = <ImportElement> [importCore, importLib];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
-    JUnitTestCase.assertEquals(type, scope.lookup(AstFactory.identifier3(typeName), importingLibrary));
+    expect(scope.lookup(AstFactory.identifier3(typeName), importingLibrary), type);
     errorListener.assertErrorsWithCodes([StaticWarningCode.CONFLICTING_DART_IMPORT]);
   }
 
   void test_nonConflictingImports_sameElement() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeNameA = "A";
     String typeNameB = "B";
     ClassElement typeA = ElementFactory.classElement2(typeNameA, []);
     ClassElement typeB = ElementFactory.classElement2(typeNameB, []);
     LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [typeA, typeB];
     ImportElementImpl import1 = ElementFactory.importFor(importedLibrary, null, []);
     ImportElementImpl import2 = ElementFactory.importFor(importedLibrary, null, []);
     LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
     importingLibrary.imports = <ImportElement> [import1, import2];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
-    JUnitTestCase.assertEquals(typeA, scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary));
+    expect(scope.lookup(AstFactory.identifier3(typeNameA), importingLibrary), typeA);
     errorListener.assertNoErrors();
-    JUnitTestCase.assertEquals(typeB, scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary));
+    expect(scope.lookup(AstFactory.identifier3(typeNameB), importingLibrary), typeB);
     errorListener.assertNoErrors();
   }
 
   void test_prefixedAndNonPrefixed() {
     AnalysisContext context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName, []);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName, []);
     LibraryElement prefixedLibrary = createTestLibrary(context, "import.prefixed", []);
     (prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [prefixedType];
     ImportElementImpl prefixedImport = ElementFactory.importFor(prefixedLibrary, ElementFactory.prefix(prefixName), []);
     LibraryElement nonPrefixedLibrary = createTestLibrary(context, "import.nonPrefixed", []);
     (nonPrefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [nonPrefixedType];
     ImportElementImpl nonPrefixedImport = ElementFactory.importFor(nonPrefixedLibrary, null, []);
     LibraryElementImpl importingLibrary = createTestLibrary(context, "importing", []);
     importingLibrary.imports = <ImportElement> [prefixedImport, nonPrefixedImport];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(importingLibrary, errorListener);
     Element prefixedElement = scope.lookup(AstFactory.identifier5(prefixName, typeName), importingLibrary);
     errorListener.assertNoErrors();
-    JUnitTestCase.assertSame(prefixedType, prefixedElement);
+    expect(prefixedElement, same(prefixedType));
     Element nonPrefixedElement = scope.lookup(AstFactory.identifier3(typeName), importingLibrary);
     errorListener.assertNoErrors();
-    JUnitTestCase.assertSame(nonPrefixedType, nonPrefixedElement);
+    expect(nonPrefixedElement, same(nonPrefixedType));
   }
 }
 
 class LibraryResolver2Test extends ResolverTestCase {
   LibraryResolver2 _resolver;
 
   Source _coreLibrarySource;
 
   @override
   void setUp() {
@@ skipping 88 matching lines @@
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl.forNode(AstFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary(context, "imported", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary(context, "importing", []);
     ImportElementImpl importElement = new ImportElementImpl(0);
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(importedType, scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary));
+    expect(scope.lookup(AstFactory.identifier3(importedTypeName), definingLibrary), importedType);
   }
 
   void test_getErrorListener() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(errorListener, scope.errorListener);
+    expect(scope.errorListener, errorListener);
   }
 }
 
 class LibraryTest extends EngineTestCase {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
 
   /**
@@ skipping 14 matching lines @@
   @override
   void setUp() {
     _sourceFactory = new SourceFactory([new FileUriResolver()]);
     _analysisContext = new AnalysisContextImpl();
     _analysisContext.sourceFactory = _sourceFactory;
     _errorListener = new GatheringErrorListener();
     _library = _createLibrary("/lib.dart");
   }
 
   void test_getExplicitlyImportsCore() {
-    JUnitTestCase.assertFalse(_library.explicitlyImportsCore);
+    expect(_library.explicitlyImportsCore, isFalse);
     _errorListener.assertNoErrors();
   }
 
   void test_getExports() {
     EngineTestCase.assertLength(0, _library.exports);
     _errorListener.assertNoErrors();
   }
 
   void test_getImports() {
     EngineTestCase.assertLength(0, _library.imports);
     _errorListener.assertNoErrors();
   }
 
   void test_getImportsAndExports() {
     _library.importedLibraries = <Library> [_createLibrary("/imported.dart")];
     _library.exportedLibraries = <Library> [_createLibrary("/exported.dart")];
     EngineTestCase.assertLength(2, _library.importsAndExports);
     _errorListener.assertNoErrors();
   }
 
   void test_getLibraryScope() {
     LibraryElementImpl element = new LibraryElementImpl.forNode(_analysisContext, AstFactory.libraryIdentifier2(["lib"]));
     element.definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     _library.libraryElement = element;
-    JUnitTestCase.assertNotNull(_library.libraryScope);
+    expect(_library.libraryScope, isNotNull);
     _errorListener.assertNoErrors();
   }
 
   void test_getLibrarySource() {
-    JUnitTestCase.assertNotNull(_library.librarySource);
+    expect(_library.librarySource, isNotNull);
   }
 
   void test_setExplicitlyImportsCore() {
     _library.explicitlyImportsCore = true;
-    JUnitTestCase.assertTrue(_library.explicitlyImportsCore);
+    expect(_library.explicitlyImportsCore, isTrue);
     _errorListener.assertNoErrors();
   }
 
   void test_setExportedLibraries() {
     Library exportLibrary = _createLibrary("/exported.dart");
     _library.exportedLibraries = <Library> [exportLibrary];
     List<Library> exports = _library.exports;
     EngineTestCase.assertLength(1, exports);
-    JUnitTestCase.assertSame(exportLibrary, exports[0]);
+    expect(exports[0], same(exportLibrary));
     _errorListener.assertNoErrors();
   }
 
   void test_setImportedLibraries() {
     Library importLibrary = _createLibrary("/imported.dart");
     _library.importedLibraries = <Library> [importLibrary];
     List<Library> imports = _library.imports;
     EngineTestCase.assertLength(1, imports);
-    JUnitTestCase.assertSame(importLibrary, imports[0]);
+    expect(imports[0], same(importLibrary));
     _errorListener.assertNoErrors();
   }
 
   void test_setLibraryElement() {
     LibraryElementImpl element = new LibraryElementImpl.forNode(_analysisContext, AstFactory.libraryIdentifier2(["lib"]));
     _library.libraryElement = element;
-    JUnitTestCase.assertSame(element, _library.libraryElement);
+    expect(_library.libraryElement, same(element));
   }
 
   @override
   void tearDown() {
     _errorListener = null;
     _sourceFactory = null;
     _analysisContext = null;
     _library = null;
     super.tearDown();
   }
 
   Library _createLibrary(String definingCompilationUnitPath) => new Library(_analysisContext, _errorListener, new FileBasedSource.con1(FileUtilities2.createFile(definingCompilationUnitPath)));
 }
 
-class MemberMapTest extends JUnitTestCase {
+class MemberMapTest {
   /**
    * The null type.
    */
   InterfaceType _nullType;
 
-  @override
   void setUp() {
     _nullType = new TestTypeProvider().nullType;
   }
 
   void test_MemberMap_copyConstructor() {
     MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
     MethodElement m2 = ElementFactory.methodElement("m2", _nullType, []);
     MethodElement m3 = ElementFactory.methodElement("m3", _nullType, []);
     MemberMap map = new MemberMap();
     map.put(m1.name, m1);
     map.put(m2.name, m2);
     map.put(m3.name, m3);
     MemberMap copy = new MemberMap.con2(map);
-    JUnitTestCase.assertEquals(map.size, copy.size);
-    JUnitTestCase.assertEquals(m1, copy.get(m1.name));
-    JUnitTestCase.assertEquals(m2, copy.get(m2.name));
-    JUnitTestCase.assertEquals(m3, copy.get(m3.name));
+    expect(copy.size, map.size);
+    expect(copy.get(m1.name), m1);
+    expect(copy.get(m2.name), m2);
+    expect(copy.get(m3.name), m3);
   }
 
   void test_MemberMap_override() {
     MethodElement m1 = ElementFactory.methodElement("m", _nullType, []);
     MethodElement m2 = ElementFactory.methodElement("m", _nullType, []);
     MemberMap map = new MemberMap();
     map.put(m1.name, m1);
     map.put(m2.name, m2);
-    JUnitTestCase.assertEquals(1, map.size);
-    JUnitTestCase.assertEquals(m2, map.get("m"));
+    expect(map.size, 1);
+    expect(map.get("m"), m2);
   }
 
   void test_MemberMap_put() {
     MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
     MemberMap map = new MemberMap();
-    JUnitTestCase.assertEquals(0, map.size);
+    expect(map.size, 0);
     map.put(m1.name, m1);
-    JUnitTestCase.assertEquals(1, map.size);
-    JUnitTestCase.assertEquals(m1, map.get("m1"));
+    expect(map.size, 1);
+    expect(map.get("m1"), m1);
   }
 }
 
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   DEBUG ? 1 : 2;
 }''');
@@ skipping 987 matching lines @@
 
   RecursiveAstVisitor_SimpleResolverTest_test_localVariable_types_invoked(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "myVar" && node.parent is MethodInvocation) {
       try {
         found[0] = true;
         // check static type
         DartType staticType = node.staticType;
-        JUnitTestCase.assertSame(SimpleResolverTest_this.typeProvider.dynamicType, staticType);
+        expect(staticType, same(SimpleResolverTest_this.typeProvider.dynamicType));
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
-        JUnitTestCase.assertEquals(SimpleResolverTest_this.typeProvider.stringType, propagatedType.returnType);
+        expect(propagatedType.returnType, SimpleResolverTest_this.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }
 
 /**
  * Instances of the class `ResolutionVerifier` verify that all of the nodes in an AST
@@ skipping 44 matching lines @@
         buffer.write(_unresolvedNodes.length);
         buffer.writeln(" nodes:");
         _printNodes(buffer, _unresolvedNodes);
       }
       if (!_wrongTypedNodes.isEmpty) {
         buffer.write("Resolved ");
         buffer.write(_wrongTypedNodes.length);
         buffer.writeln(" to the wrong type of element:");
         _printNodes(buffer, _wrongTypedNodes);
       }
-      JUnitTestCase.fail(buffer.toString());
+      fail(buffer.toString());
     }
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     node.visitChildren(this);
     ElementAnnotation elementAnnotation = node.elementAnnotation;
     if (elementAnnotation == null) {
       if (_knownExceptions == null || !_knownExceptions.contains(node)) {
         _unresolvedNodes.add(node);
@@ skipping 529 matching lines @@
   void test_scopeFor_MethodDeclaration_body() {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(_createResolvedMethodDeclaration().body, listener);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionScope, FunctionScope, scope);
   }
 
   void test_scopeFor_notInCompilationUnit() {
     GatheringErrorListener listener = new GatheringErrorListener();
     try {
       ScopeBuilder.scopeFor(AstFactory.identifier3("x"), listener);
-      JUnitTestCase.fail("Expected AnalysisException");
+      fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   void test_scopeFor_null() {
     GatheringErrorListener listener = new GatheringErrorListener();
     try {
       ScopeBuilder.scopeFor(null, listener);
-      JUnitTestCase.fail("Expected AnalysisException");
+      fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   void test_scopeFor_unresolved() {
     GatheringErrorListener listener = new GatheringErrorListener();
     try {
       ScopeBuilder.scopeFor(AstFactory.compilationUnit(), listener);
-      JUnitTestCase.fail("Expected AnalysisException");
+      fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   ClassDeclaration _createResolvedClassDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
     ClassDeclaration classNode = AstFactory.classDeclaration(null, className, AstFactory.typeParameterList([]), null, null, null, []);
     unit.declarations.add(classNode);
@@ skipping 83 matching lines @@
     VariableElement element1 = ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(AstFactory.identifier3("v2"));
     scope.define(element1);
     scope.define(element2);
     errorListener.assertNoErrors();
   }
 
   void test_getErrorListener() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
-    JUnitTestCase.assertEquals(errorListener, scope.errorListener);
+    expect(scope.errorListener, errorListener);
   }
 
   void test_isPrivateName_nonPrivate() {
-    JUnitTestCase.assertFalse(Scope.isPrivateName("Public"));
+    expect(Scope.isPrivateName("Public"), isFalse);
   }
 
   void test_isPrivateName_private() {
-    JUnitTestCase.assertTrue(Scope.isPrivateName("_Private"));
+    expect(Scope.isPrivateName("_Private"), isTrue);
   }
 }
 
 /**
  * A non-abstract subclass that can be used for testing purposes.
  */
 class ScopeTest_TestScope extends Scope {
   /**
    * The listener that is to be informed when an error is encountered.
    */
@@ skipping 159 matching lines @@
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
-    JUnitTestCase.assertNull(rhs.staticParameterElement);
+    expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
-    JUnitTestCase.assertNotNull(parameter);
-    JUnitTestCase.assertEquals("x", parameter.displayName);
+    expect(parameter, isNotNull);
+    expect(parameter.displayName, "x");
     // validate
     ClassElement classA = unit.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
-    JUnitTestCase.assertSame(parameter, setter.parameters[0]);
+    expect(setter.parameters[0], same(parameter));
   }
 
   void test_argumentResolution_setter_propagated_propertyAccess() {
     Source source = addSource(r'''
 main() {
   var a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
-    JUnitTestCase.assertNull(rhs.staticParameterElement);
+    expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
-    JUnitTestCase.assertNotNull(parameter);
-    JUnitTestCase.assertEquals("x", parameter.displayName);
+    expect(parameter, isNotNull);
+    expect(parameter.displayName, "x");
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
-    JUnitTestCase.assertSame(parameter, setter.parameters[0]);
+    expect(setter.parameters[0], same(parameter));
   }
 
   void test_argumentResolution_setter_static() {
     Source source = addSource(r'''
 main() {
   A a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
-    JUnitTestCase.assertNotNull(parameter);
-    JUnitTestCase.assertEquals("x", parameter.displayName);
+    expect(parameter, isNotNull);
+    expect(parameter.displayName, "x");
     // validate
     ClassElement classA = unit.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
-    JUnitTestCase.assertSame(parameter, setter.parameters[0]);
+    expect(setter.parameters[0], same(parameter));
   }
 
   void test_argumentResolution_setter_static_propertyAccess() {
     Source source = addSource(r'''
 main() {
   A a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
-    JUnitTestCase.assertNotNull(parameter);
-    JUnitTestCase.assertEquals("x", parameter.displayName);
+    expect(parameter, isNotNull);
+    expect(parameter.displayName, "x");
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
-    JUnitTestCase.assertSame(parameter, setter.parameters[0]);
+    expect(setter.parameters[0], same(parameter));
   }
 
   void test_class_definesCall() {
     Source source = addSource(r'''
 class A {
   int call(int x) { return x; }
 }
 int f(A a) {
   return a(0);
 }''');
@@ skipping 56 matching lines @@
   }
 
   void test_entryPoint_exported() {
     addNamedSource("/two.dart", r'''
 library two;
 main() {}''');
     Source source = addNamedSource("/one.dart", r'''
 library one;
 export 'two.dart';''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
-    JUnitTestCase.assertNotNull(main);
-    JUnitTestCase.assertNotSame(library, main.library);
+    expect(main, isNotNull);
+    expect(main.library, isNot(same(library)));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_local() {
     Source source = addNamedSource("/one.dart", r'''
 library one;
 main() {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     FunctionElement main = library.entryPoint;
-    JUnitTestCase.assertNotNull(main);
-    JUnitTestCase.assertSame(library, main.library);
+    expect(main, isNotNull);
+    expect(main.library, same(library));
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_none() {
     Source source = addNamedSource("/one.dart", "library one;");
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
-    JUnitTestCase.assertNull(library.entryPoint);
+    expect(library, isNotNull);
+    expect(library.entryPoint, isNull);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_extractedMethodAsConstant() {
     Source source = addSource(r'''
 abstract class Comparable<T> {
   int compareTo(T other);
   static int compare(Comparable a, Comparable b) => a.compareTo(b);
 }
@@ skipping 67 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
 
   void test_hasReferenceToSuper() {
     Source source = addSource(r'''
 class A {}
 class B {toString() => super.toString();}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
-    JUnitTestCase.assertFalse(classes[0].hasReferenceToSuper);
-    JUnitTestCase.assertTrue(classes[1].hasReferenceToSuper);
+    expect(classes[0].hasReferenceToSuper, isFalse);
+    expect(classes[1].hasReferenceToSuper, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_hide() {
     addNamedSource("lib1.dart", r'''
 library lib1;
 set foo(value) {}
 class A {}''');
     addNamedSource("lib2.dart", r'''
@@ skipping 103 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_badSuperclass() {
     Source source = addSource(r'''
 class A extends B {}
 class B {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
-    JUnitTestCase.assertFalse(classes[0].isValidMixin);
+    expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_constructor() {
     Source source = addSource(r'''
 class A {
   A() {}
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
-    JUnitTestCase.assertFalse(classes[0].isValidMixin);
+    expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_super() {
     Source source = addSource(r'''
 class A {
   toString() {
     return super.toString();
   }
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
-    JUnitTestCase.assertFalse(classes[0].isValidMixin);
+    expect(classes[0].isValidMixin, isFalse);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_valid() {
     Source source = addSource("class A {}");
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
-    JUnitTestCase.assertTrue(classes[0].isValidMixin);
+    expect(classes[0].isValidMixin, isTrue);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_labels_switch() {
     Source source = addSource(r'''
 void doSwitch(int target) {
   switch (target) {
     l0: case 0:
       continue l1;
     l1: case 1:
       continue l0;
     default:
       continue l1;
   }
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_localVariable_types_invoked() {
     Source source = addSource(r'''
 const A = null;
 main() {
   var myVar = (int p) => 'foo';
   myVar(42);
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnit unit = analysisContext.getResolvedCompilationUnit(source, library);
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<bool> found = [false];
     List<CaughtException> thrownException = new List<CaughtException>(1);
     unit.accept(new RecursiveAstVisitor_SimpleResolverTest_test_localVariable_types_invoked(this, found, thrownException));
     if (thrownException[0] != null) {
       throw new AnalysisException("Exception", new CaughtException(thrownException[0], null));
     }
-    JUnitTestCase.assertTrue(found[0]);
+    expect(found[0], isTrue);
   }
 
   void test_metadata_class() {
     Source source = addSource(r'''
 const A = null;
 @A class C<A> {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unitElement);
+    expect(unitElement, isNotNull);
     List<ClassElement> classes = unitElement.types;
     EngineTestCase.assertLength(1, classes);
     List<ElementAnnotation> annotations = classes[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(2, declarations);
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
-    JUnitTestCase.assertSame(expectedElement, actualElement);
+    expect(actualElement, same(expectedElement));
   }
 
   void test_metadata_field() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A int f;
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     FieldElement field = classes[0].fields[0];
     List<ElementAnnotation> annotations = field.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_fieldFormalParameter() {
     Source source = addSource(r'''
 const A = null;
 class C {
   int f;
   C(@A this.f);
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     List<ConstructorElement> constructors = classes[0].constructors;
     EngineTestCase.assertLength(1, constructors);
     List<ParameterElement> parameters = constructors[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_function() {
     Source source = addSource(r'''
 const A = null;
 @A f() {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ElementAnnotation> annotations = functions[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_functionTypedParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A int p(int x)) {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_libraryDirective() {
     Source source = addSource(r'''
 @A library lib;
 const A = null;''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     List<ElementAnnotation> annotations = library.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_method() {
     Source source = addSource(r'''
 const A = null;
 class C {
   @A void m() {}
 }''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     MethodElement method = classes[0].methods[0];
     List<ElementAnnotation> annotations = method.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_namedParameter() {
     Source source = addSource(r'''
 const A = null;
 f({@A int p : 0}) {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_positionalParameter() {
     Source source = addSource(r'''
 const A = null;
 f([@A int p = 0]) {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_simpleParameter() {
     Source source = addSource(r'''
 const A = null;
 f(@A p1, @A int p2) {}''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unit = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(2, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     List<ElementAnnotation> annotations2 = parameters[1].metadata;
     EngineTestCase.assertLength(1, annotations2);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_typedef() {
     Source source = addSource(r'''
 const A = null;
 @A typedef F<A>();''');
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
-    JUnitTestCase.assertNotNull(unitElement);
+    expect(unitElement, isNotNull);
     List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
     EngineTestCase.assertLength(1, aliases);
     List<ElementAnnotation> annotations = aliases[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(2, declarations);
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
-    JUnitTestCase.assertSame(expectedElement, actualElement);
+    expect(actualElement, same(expectedElement));
   }
 
   void test_method_fromMixin() {
     Source source = addSource(r'''
 class B {
   bar() => 1;
 }
 class A {
   foo() => 2;
 }
@@ skipping 112 matching lines @@
    * parameters at that index. Arguments that should not be resolved to a parameter because of an
    * error can be denoted by including a negative index in the array of indices.
    *
    * @param source the source to be resolved
    * @param indices the array of indices used to associate arguments with parameters
    * @throws Exception if the source could not be resolved or if the structure of the source is not
    *           valid
    */
   void _validateArgumentResolution(Source source, List<int> indices) {
     LibraryElement library = resolve(source);
-    JUnitTestCase.assertNotNull(library);
+    expect(library, isNotNull);
     ClassElement classElement = library.definingCompilationUnit.types[0];
     List<ParameterElement> parameters = classElement.methods[1].parameters;
     CompilationUnit unit = resolveCompilationUnit(source, library);
-    JUnitTestCase.assertNotNull(unit);
+    expect(unit, isNotNull);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     MethodDeclaration methodDeclaration = classDeclaration.members[0] as MethodDeclaration;
     Block block = (methodDeclaration.body as BlockFunctionBody).block;
     ExpressionStatement statement = block.statements[0] as ExpressionStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     NodeList<Expression> arguments = invocation.argumentList.arguments;
     int argumentCount = arguments.length;
-    JUnitTestCase.assertEquals(indices.length, argumentCount);
+    expect(argumentCount, indices.length);
     for (int i = 0; i < argumentCount; i++) {
       Expression argument = arguments[i];
       ParameterElement element = argument.staticParameterElement;
       int index = indices[i];
       if (index < 0) {
-        JUnitTestCase.assertNull(element);
+        expect(element, isNull);
       } else {
-        JUnitTestCase.assertSame(parameters[index], element);
+        expect(element, same(parameters[index]));
       }
     }
   }
 }
 
 class SourceContainer_ChangeSetTest_test_toString implements SourceContainer {
   @override
   bool contains(Source source) => false;
 }
 
@@ skipping 12 matching lines @@
    * The analyzer being used to analyze the test cases.
    */
   StaticTypeAnalyzer _analyzer;
 
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
   void fail_visitFunctionExpressionInvocation() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitMethodInvocation() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitSimpleIdentifier() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
     _typeProvider = new TestTypeProvider();
     _analyzer = _createAnalyzer();
   }
 
   void test_visitAdjacentStrings() {
     // "a" "b"
     Expression node = AstFactory.adjacentStrings([_resolvedString("a"), _resolvedString("b")]);
-    JUnitTestCase.assertSame(_typeProvider.stringType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitAsExpression() {
     // class A { ... this as B ... }
     // class B extends A {}
     ClassElement superclass = ElementFactory.classElement2("A", []);
     InterfaceType superclassType = superclass.type;
     ClassElement subclass = ElementFactory.classElement("B", superclassType, []);
     Expression node = AstFactory.asExpression(AstFactory.thisExpression(), AstFactory.typeName(subclass, []));
-    JUnitTestCase.assertSame(subclass.type, _analyze3(node, superclassType));
+    expect(_analyze3(node, superclassType), same(subclass.type));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_compound() {
     // i += 1
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier identifier = _resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = AstFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, _resolvedInteger(1));
     MethodElement plusMethod = getMethod(numType, "+");
     node.staticElement = plusMethod;
-    JUnitTestCase.assertSame(numType, _analyze(node));
+    expect(_analyze(node), same(numType));
     _listener.assertNoErrors();
   }
 
   void test_visitAssignmentExpression_simple() {
     // i = 0
     InterfaceType intType = _typeProvider.intType;
     Expression node = AstFactory.assignmentExpression(_resolvedVariable(intType, "i"), TokenType.EQ, _resolvedInteger(0));
-    JUnitTestCase.assertSame(intType, _analyze(node));
+    expect(_analyze(node), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_equals() {
     // 2 == 3
     Expression node = AstFactory.binaryExpression(_resolvedInteger(2), TokenType.EQ_EQ, _resolvedInteger(3));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalAnd() {
     // false && true
     Expression node = AstFactory.binaryExpression(AstFactory.booleanLiteral(false), TokenType.AMPERSAND_AMPERSAND, AstFactory.booleanLiteral(true));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_logicalOr() {
     // false || true
     Expression node = AstFactory.binaryExpression(AstFactory.booleanLiteral(false), TokenType.BAR_BAR, AstFactory.booleanLiteral(true));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_notEquals() {
     // 2 != 3
     Expression node = AstFactory.binaryExpression(_resolvedInteger(2), TokenType.BANG_EQ, _resolvedInteger(3));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plusID() {
     // 1 + 2.0
     BinaryExpression node = AstFactory.binaryExpression(_resolvedInteger(1), TokenType.PLUS, _resolvedDouble(2.0));
     node.staticElement = getMethod(_typeProvider.numType, "+");
-    JUnitTestCase.assertSame(_typeProvider.doubleType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_plusII() {
     // 1 + 2
     BinaryExpression node = AstFactory.binaryExpression(_resolvedInteger(1), TokenType.PLUS, _resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "+");
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_slash() {
     // 2 / 2
     BinaryExpression node = AstFactory.binaryExpression(_resolvedInteger(2), TokenType.SLASH, _resolvedInteger(2));
     node.staticElement = getMethod(_typeProvider.numType, "/");
-    JUnitTestCase.assertSame(_typeProvider.doubleType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_star_notSpecial() {
     // class A {
     //   A operator *(double value);
     // }
     // (a as A) * 2.0
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     MethodElement operator = ElementFactory.methodElement("*", typeA, [_typeProvider.doubleType]);
     classA.methods = <MethodElement> [operator];
     BinaryExpression node = AstFactory.binaryExpression(AstFactory.asExpression(AstFactory.identifier3("a"), AstFactory.typeName(classA, [])), TokenType.PLUS, _resolvedDouble(2.0));
     node.staticElement = operator;
-    JUnitTestCase.assertSame(typeA, _analyze(node));
+    expect(_analyze(node), same(typeA));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_starID() {
     // 1 * 2.0
     BinaryExpression node = AstFactory.binaryExpression(_resolvedInteger(1), TokenType.PLUS, _resolvedDouble(2.0));
     node.staticElement = getMethod(_typeProvider.numType, "*");
-    JUnitTestCase.assertSame(_typeProvider.doubleType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitBooleanLiteral_false() {
     // false
     Expression node = AstFactory.booleanLiteral(false);
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitBooleanLiteral_true() {
     // true
     Expression node = AstFactory.booleanLiteral(true);
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitCascadeExpression() {
     // a..length
     Expression node = AstFactory.cascadeExpression(_resolvedString("a"), [AstFactory.propertyAccess2(null, "length")]);
-    JUnitTestCase.assertSame(_typeProvider.stringType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_differentTypes() {
     // true ? 1.0 : 0
     Expression node = AstFactory.conditionalExpression(AstFactory.booleanLiteral(true), _resolvedDouble(1.0), _resolvedInteger(0));
-    JUnitTestCase.assertSame(_typeProvider.numType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.numType));
     _listener.assertNoErrors();
   }
 
   void test_visitConditionalExpression_sameTypes() {
     // true ? 1 : 0
     Expression node = AstFactory.conditionalExpression(AstFactory.booleanLiteral(true), _resolvedInteger(1), _resolvedInteger(0));
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitDoubleLiteral() {
     // 4.33
     Expression node = AstFactory.doubleLiteral(4.33);
-    JUnitTestCase.assertSame(_typeProvider.doubleType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.doubleType));
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_named_block() {
     // ({p1 : 0, p2 : 0}) {}
     DartType dynamicType = _typeProvider.dynamicType;
     FormalParameter p1 = AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p1"), _resolvedInteger(0));
     _setType(p1, dynamicType);
     FormalParameter p2 = AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p2"), _resolvedInteger(0));
     _setType(p2, dynamicType);
@@ skipping 139 matching lines @@
   }
 
   void test_visitIndexExpression_getter() {
     // List a;
     // a[2]
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = _resolvedVariable(listType, "a");
     IndexExpression node = AstFactory.indexExpression(identifier, _resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[0];
     node.staticElement = indexMethod;
-    JUnitTestCase.assertSame(listType.typeArguments[0], _analyze(node));
+    expect(_analyze(node), same(listType.typeArguments[0]));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_setter() {
     // List a;
     // a[2] = 0
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = _resolvedVariable(listType, "a");
     IndexExpression node = AstFactory.indexExpression(identifier, _resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[1];
     node.staticElement = indexMethod;
     AstFactory.assignmentExpression(node, TokenType.EQ, AstFactory.integer(0));
-    JUnitTestCase.assertSame(listType.typeArguments[0], _analyze(node));
+    expect(_analyze(node), same(listType.typeArguments[0]));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_typeParameters() {
     // List<int> list = ...
     // list[0]
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     // (int) -> E
     MethodElement methodElement = getMethod(listType, "[]");
     // "list" has type List<int>
     SimpleIdentifier identifier = AstFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<DartType> [intType]);
     identifier.staticType = listOfIntType;
     // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression = AstFactory.indexExpression(identifier, AstFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
     // analyze and assert result of the index expression
-    JUnitTestCase.assertSame(intType, _analyze(indexExpression));
+    expect(_analyze(indexExpression), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_typeParameters_inSetterContext() {
     // List<int> list = ...
     // list[0] = 0;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     // (int, E) -> void
     MethodElement methodElement = getMethod(listType, "[]=");
     // "list" has type List<int>
     SimpleIdentifier identifier = AstFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<DartType> [intType]);
     identifier.staticType = listOfIntType;
     // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression = AstFactory.indexExpression(identifier, AstFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
     // list[0] should be in a setter context
     AstFactory.assignmentExpression(indexExpression, TokenType.EQ, AstFactory.integer(0));
     // analyze and assert result of the index expression
-    JUnitTestCase.assertSame(intType, _analyze(indexExpression));
+    expect(_analyze(indexExpression), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_named() {
     // new C.m()
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, constructorName, []);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement, []), [AstFactory.identifier3(constructorName)]);
     node.staticElement = constructor;
-    JUnitTestCase.assertSame(classElement.type, _analyze(node));
+    expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_typeParameters() {
     // new C<I>()
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(elementC, null, []);
     elementC.constructors = <ConstructorElement> [constructor];
     constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     TypeName typeName = AstFactory.typeName(elementC, [AstFactory.typeName(elementI, [])]);
     typeName.type = elementC.type.substitute4(<DartType> [elementI.type]);
     InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, typeName, []);
     node.staticElement = constructor;
     InterfaceType interfaceType = _analyze(node) as InterfaceType;
     List<DartType> typeArgs = interfaceType.typeArguments;
-    JUnitTestCase.assertEquals(1, typeArgs.length);
-    JUnitTestCase.assertEquals(elementI.type, typeArgs[0]);
+    expect(typeArgs.length, 1);
+    expect(typeArgs[0], elementI.type);
     _listener.assertNoErrors();
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
     // new C()
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     ConstructorElementImpl constructor = ElementFactory.constructorElement2(classElement, null, []);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
     constructor.type = constructorType;
     classElement.constructors = <ConstructorElement> [constructor];
     InstanceCreationExpression node = AstFactory.instanceCreationExpression2(null, AstFactory.typeName(classElement, []), []);
     node.staticElement = constructor;
-    JUnitTestCase.assertSame(classElement.type, _analyze(node));
+    expect(_analyze(node), same(classElement.type));
     _listener.assertNoErrors();
   }
 
   void test_visitIntegerLiteral() {
     // 42
     Expression node = _resolvedInteger(42);
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_negated() {
     // a is! String
     Expression node = AstFactory.isExpression(_resolvedString("a"), true, AstFactory.typeName4("String", []));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitIsExpression_notNegated() {
     // a is String
     Expression node = AstFactory.isExpression(_resolvedString("a"), false, AstFactory.typeName4("String", []));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_empty() {
     // []
     Expression node = AstFactory.listLiteral([]);
     DartType resultType = _analyze(node);
     _assertType2(_typeProvider.listType.substitute4(<DartType> [_typeProvider.dynamicType]), resultType);
     _listener.assertNoErrors();
   }
@@ skipping 25 matching lines @@
   void test_visitMethodInvocation_then() {
     // then()
     Expression node = AstFactory.methodInvocation(null, "then", []);
     _analyze(node);
     _listener.assertNoErrors();
   }
 
   void test_visitNamedExpression() {
     // n: a
     Expression node = AstFactory.namedExpression2("n", _resolvedString("a"));
-    JUnitTestCase.assertSame(_typeProvider.stringType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitNullLiteral() {
     // null
     Expression node = AstFactory.nullLiteral();
-    JUnitTestCase.assertSame(_typeProvider.bottomType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.bottomType));
     _listener.assertNoErrors();
   }
 
   void test_visitParenthesizedExpression() {
     // (0)
     Expression node = AstFactory.parenthesizedExpression(_resolvedInteger(0));
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression_minusMinus() {
     // 0--
     PostfixExpression node = AstFactory.postfixExpression(_resolvedInteger(0), TokenType.MINUS_MINUS);
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPostfixExpression_plusPlus() {
     // 0++
     PostfixExpression node = AstFactory.postfixExpression(_resolvedInteger(0), TokenType.PLUS_PLUS);
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_getter() {
     DartType boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PrefixedIdentifier node = AstFactory.identifier5("a", "b");
     node.identifier.staticElement = getter;
-    JUnitTestCase.assertSame(boolType, _analyze(node));
+    expect(_analyze(node), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_setter() {
     DartType boolType = _typeProvider.boolType;
     FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
     PropertyAccessorElement setter = field.setter;
     PrefixedIdentifier node = AstFactory.identifier5("a", "b");
     node.identifier.staticElement = setter;
-    JUnitTestCase.assertSame(boolType, _analyze(node));
+    expect(_analyze(node), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixedIdentifier_variable() {
     VariableElementImpl variable = ElementFactory.localVariableElement2("b");
     variable.type = _typeProvider.boolType;
     PrefixedIdentifier node = AstFactory.identifier5("a", "b");
     node.identifier.staticElement = variable;
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_bang() {
     // !0
     PrefixExpression node = AstFactory.prefixExpression(TokenType.BANG, _resolvedInteger(0));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_minus() {
     // -0
     PrefixExpression node = AstFactory.prefixExpression(TokenType.MINUS, _resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
-    JUnitTestCase.assertSame(_typeProvider.numType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.numType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_minusMinus() {
     // --0
     PrefixExpression node = AstFactory.prefixExpression(TokenType.MINUS_MINUS, _resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_not() {
     // !true
     Expression node = AstFactory.prefixExpression(TokenType.BANG, AstFactory.booleanLiteral(true));
-    JUnitTestCase.assertSame(_typeProvider.boolType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_plusPlus() {
     // ++0
     PrefixExpression node = AstFactory.prefixExpression(TokenType.PLUS_PLUS, _resolvedInteger(0));
     MethodElement plusMethod = getMethod(_typeProvider.numType, "+");
     node.staticElement = plusMethod;
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPrefixExpression_tilde() {
     // ~0
     PrefixExpression node = AstFactory.prefixExpression(TokenType.TILDE, _resolvedInteger(0));
     MethodElement tildeMethod = getMethod(_typeProvider.intType, "~");
     node.staticElement = tildeMethod;
-    JUnitTestCase.assertSame(_typeProvider.intType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.intType));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_propagated_getter() {
     DartType boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node = AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b");
     node.propertyName.propagatedElement = getter;
-    JUnitTestCase.assertSame(boolType, _analyze2(node, false));
+    expect(_analyze2(node, false), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_propagated_setter() {
     DartType boolType = _typeProvider.boolType;
     FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
     PropertyAccessorElement setter = field.setter;
     PropertyAccess node = AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b");
     node.propertyName.propagatedElement = setter;
-    JUnitTestCase.assertSame(boolType, _analyze2(node, false));
+    expect(_analyze2(node, false), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_static_getter() {
     DartType boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node = AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b");
     node.propertyName.staticElement = getter;
-    JUnitTestCase.assertSame(boolType, _analyze(node));
+    expect(_analyze(node), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitPropertyAccess_static_setter() {
     DartType boolType = _typeProvider.boolType;
     FieldElementImpl field = ElementFactory.fieldElement("b", false, false, false, boolType);
     PropertyAccessorElement setter = field.setter;
     PropertyAccess node = AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b");
     node.propertyName.staticElement = setter;
-    JUnitTestCase.assertSame(boolType, _analyze(node));
+    expect(_analyze(node), same(boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleStringLiteral() {
     // "a"
     Expression node = _resolvedString("a");
-    JUnitTestCase.assertSame(_typeProvider.stringType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitStringInterpolation() {
     // "a${'b'}c"
     Expression node = AstFactory.string([
         AstFactory.interpolationString("a", "a"),
         AstFactory.interpolationExpression(_resolvedString("b")),
         AstFactory.interpolationString("c", "c")]);
-    JUnitTestCase.assertSame(_typeProvider.stringType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.stringType));
     _listener.assertNoErrors();
   }
 
   void test_visitSuperExpression() {
     // super
     InterfaceType superType = ElementFactory.classElement2("A", []).type;
     InterfaceType thisType = ElementFactory.classElement("B", superType, []).type;
     Expression node = AstFactory.superExpression();
-    JUnitTestCase.assertSame(thisType, _analyze3(node, thisType));
+    expect(_analyze3(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitSymbolLiteral() {
-    JUnitTestCase.assertSame(_typeProvider.symbolType, _analyze(AstFactory.symbolLiteral(["a"])));
+    expect(_analyze(AstFactory.symbolLiteral(["a"])), same(_typeProvider.symbolType));
   }
 
   void test_visitThisExpression() {
     // this
     InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.classElement2("A", []).type, []).type;
     Expression node = AstFactory.thisExpression();
-    JUnitTestCase.assertSame(thisType, _analyze3(node, thisType));
+    expect(_analyze3(node, thisType), same(thisType));
     _listener.assertNoErrors();
   }
 
   void test_visitThrowExpression_withoutValue() {
     // throw
     Expression node = AstFactory.throwExpression();
-    JUnitTestCase.assertSame(_typeProvider.bottomType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.bottomType));
     _listener.assertNoErrors();
   }
 
   void test_visitThrowExpression_withValue() {
     // throw 0
     Expression node = AstFactory.throwExpression2(_resolvedInteger(0));
-    JUnitTestCase.assertSame(_typeProvider.bottomType, _analyze(node));
+    expect(_analyze(node), same(_typeProvider.bottomType));
     _listener.assertNoErrors();
   }
 
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
    *
    * @param node the expression with which the type is associated
    * @return the type associated with the expression
    */
@@ skipping 68 matching lines @@
   void _assertFunctionType(DartType expectedReturnType, List<DartType> expectedNormalTypes, List<DartType> expectedOptionalTypes, Map<String, DartType> expectedNamedTypes, DartType actualType) {
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionType, FunctionType, actualType);
     FunctionType functionType = actualType as FunctionType;
     List<DartType> normalTypes = functionType.normalParameterTypes;
     if (expectedNormalTypes == null) {
       EngineTestCase.assertLength(0, normalTypes);
     } else {
       int expectedCount = expectedNormalTypes.length;
       EngineTestCase.assertLength(expectedCount, normalTypes);
       for (int i = 0; i < expectedCount; i++) {
-        JUnitTestCase.assertSame(expectedNormalTypes[i], normalTypes[i]);
+        expect(normalTypes[i], same(expectedNormalTypes[i]));
       }
     }
     List<DartType> optionalTypes = functionType.optionalParameterTypes;
     if (expectedOptionalTypes == null) {
       EngineTestCase.assertLength(0, optionalTypes);
     } else {
       int expectedCount = expectedOptionalTypes.length;
       EngineTestCase.assertLength(expectedCount, optionalTypes);
       for (int i = 0; i < expectedCount; i++) {
-        JUnitTestCase.assertSame(expectedOptionalTypes[i], optionalTypes[i]);
+        expect(optionalTypes[i], same(expectedOptionalTypes[i]));
       }
     }
     Map<String, DartType> namedTypes = functionType.namedParameterTypes;
     if (expectedNamedTypes == null) {
       EngineTestCase.assertSizeOfMap(0, namedTypes);
     } else {
       EngineTestCase.assertSizeOfMap(expectedNamedTypes.length, namedTypes);
       expectedNamedTypes.forEach((String name, DartType type) {
-        JUnitTestCase.assertSame(type, namedTypes[name]);
+        expect(namedTypes[name], same(type));
       });
     }
-    JUnitTestCase.assertSame(expectedReturnType, functionType.returnType);
+    expect(functionType.returnType, same(expectedReturnType));
   }
 
   void _assertType(InterfaceTypeImpl expectedType, InterfaceTypeImpl actualType) {
-    JUnitTestCase.assertEquals(expectedType.displayName, actualType.displayName);
-    JUnitTestCase.assertEquals(expectedType.element, actualType.element);
+    expect(actualType.displayName, expectedType.displayName);
+    expect(actualType.element, expectedType.element);
     List<DartType> expectedArguments = expectedType.typeArguments;
     int length = expectedArguments.length;
     List<DartType> actualArguments = actualType.typeArguments;
     EngineTestCase.assertLength(length, actualArguments);
     for (int i = 0; i < length; i++) {
       _assertType2(expectedArguments[i], actualArguments[i]);
     }
   }
 
   void _assertType2(DartType expectedType, DartType actualType) {
@@ skipping 139 matching lines @@
 typedef Foo();
 main() {
   Foo foo;
   foo();
 }
 """;
     _resolveTestUnit(code);
     // "foo" should be resolved to the "Foo" type
     SimpleIdentifier identifier = _findIdentifier("foo();");
     DartType type = identifier.staticType;
-    _ut.expect(type, new _ut.isInstanceOf<FunctionType>());
+    expect(type, new isInstanceOf<FunctionType>());
   }
 
   void test_MethodInvocation_nameType_parameter_FunctionTypeAlias() {
     String code = r"""
 typedef Foo();
 main(Foo foo) {
   foo();
 }
 """;
     _resolveTestUnit(code);
     // "foo" should be resolved to the "Foo" type
     SimpleIdentifier identifier = _findIdentifier("foo();");
     DartType type = identifier.staticType;
-    _ut.expect(type, new _ut.isInstanceOf<FunctionType>());
+    expect(type, new isInstanceOf<FunctionType>());
   }
 
   void test_MethodInvocation_nameType_parameter_propagatedType() {
     String code = r"""
 typedef Foo();
 main(p) {
   if (p is Foo) {
     p();
   }
 }
 """;
     _resolveTestUnit(code);
     SimpleIdentifier identifier = _findIdentifier("p()");
-    _ut.expect(identifier.staticType, DynamicTypeImpl.instance);
+    expect(identifier.staticType, DynamicTypeImpl.instance);
     {
       FunctionType type = identifier.propagatedType;
-      _ut.expect(type, _ut.isNotNull);
-      _ut.expect(type.name, 'Foo');
+      expect(type, isNotNull);
+      expect(type.name, 'Foo');
     }
   }
 
   SimpleIdentifier _findIdentifier(String search) {
     SimpleIdentifier identifier = EngineTestCase.findNode(
         testUnit,
         testCode,
         search,
         (node) => node is SimpleIdentifier);
     return identifier;
@@ skipping 100 matching lines @@
           buffer.write(", ");
           buffer.write(expression.propagatedType.displayName);
           buffer.writeln("]");
           buffer.write("    ");
           buffer.write(_getFileName(expression));
           buffer.write(" : ");
           buffer.write(expression.offset);
           buffer.writeln(")");
         }
       }
-      JUnitTestCase.fail(buffer.toString());
+      fail(buffer.toString());
     }
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) => null;
 
   @override
   Object visitCommentReference(CommentReference node) => null;
 
   @override
@@ skipping 774 matching lines @@
       functionType.typeArguments = typeArguments;
     }
   }
 }
 
 class TypeOverrideManagerTest extends EngineTestCase {
   void test_exitScope_noScopes() {
     TypeOverrideManager manager = new TypeOverrideManager();
     try {
       manager.exitScope();
-      JUnitTestCase.fail("Expected IllegalStateException");
+      fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
       // Expected
     }
   }
 
   void test_exitScope_oneScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     manager.exitScope();
     try {
       manager.exitScope();
-      JUnitTestCase.fail("Expected IllegalStateException");
+      fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
       // Expected
     }
   }
 
   void test_exitScope_twoScopes() {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
     manager.exitScope();
     manager.enterScope();
     manager.exitScope();
     try {
       manager.exitScope();
-      JUnitTestCase.fail("Expected IllegalStateException");
+      fail("Expected IllegalStateException");
     } on IllegalStateException catch (exception) {
       // Expected
     }
   }
 
   void test_getType_enclosedOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
     InterfaceType type = ElementFactory.classElement2("C", []).type;
     manager.enterScope();
     manager.setType(element, type);
     manager.enterScope();
-    JUnitTestCase.assertSame(type, manager.getType(element));
+    expect(manager.getType(element), same(type));
   }
 
   void test_getType_immediateOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     LocalVariableElementImpl element = ElementFactory.localVariableElement2("v");
     InterfaceType type = ElementFactory.classElement2("C", []).type;
     manager.enterScope();
     manager.setType(element, type);
-    JUnitTestCase.assertSame(type, manager.getType(element));
+    expect(manager.getType(element), same(type));
   }
 
   void test_getType_noOverride() {
     TypeOverrideManager manager = new TypeOverrideManager();
     manager.enterScope();
-    JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
+    expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
-    JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
+    expect(manager.getType(ElementFactory.localVariableElement2("v")), isNull);
   }
 }
 
 
 class TypePropagationTest extends ResolverTestCase {
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(r'''
 f1(x) {
   var y = [];
@@ skipping 72 matching lines @@
       d = false;
     } else {
       x = '';
       c = true;
       continue;
     }
     x; // marker
   }
 }''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
-    JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
-    JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
+    expect(typeProvider.intType.isSubtypeOf(t), isTrue);
+    expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_8() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In nested loops [breaks]s are unsafe for the purposes of [isAbruptTerminationStatement].
     //
     // This is a combination of 6 and 7: we use an unlabeled [break]
     // like a continue for the outer loop / like a labeled [break] to
     // jump just above the [if].
     String code = r'''
 f() {
   var x = 0;
   var c = false;
   var d = true;
   while (d) {
     while (d) {
       if (c) {
         d = false;
       } else {
         x = '';
         c = true;
         break;
       }
       x; // marker
     }
   }
 }''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
-    JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
-    JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
+    expect(typeProvider.intType.isSubtypeOf(t), isTrue);
+    expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   void fail_propagatedReturnType_functionExpression() {
     // TODO(scheglov) disabled because we don't resolve function expression
     String code = r'''
 main() {
   var v = (() {return 42;})();
 }''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
@@ skipping 14 matching lines @@
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_assert() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_assignment() {
     Source source = addSource(r'''
 f() {
   var v;
   v = 0;
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeProvider.intType));
   }
 
   void test_assignment_afterInitializer() {
     Source source = addSource(r'''
 f() {
   var v = 0;
   v = 1.0;
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeProvider.doubleType, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeProvider.doubleType));
   }
 
   void test_assignment_null() {
     String code = r'''
 main() {
   int v; // declare
   v = null;
   return v; // return
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve(source);
       assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // declare", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
-      JUnitTestCase.assertSame(null, identifier.propagatedType);
+      expect(identifier.staticType, same(typeProvider.intType));
+      expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = null;", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
-      JUnitTestCase.assertSame(null, identifier.propagatedType);
+      expect(identifier.staticType, same(typeProvider.intType));
+      expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // return", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
-      JUnitTestCase.assertSame(null, identifier.propagatedType);
+      expect(identifier.staticType, same(typeProvider.intType));
+      expect(identifier.propagatedType, same(null));
     }
   }
 
   void test_CanvasElement_getContext() {
     String code = r'''
 import 'dart:html';
 main(CanvasElement canvas) {
   var context = canvas.getContext('2d');
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "context", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertEquals("CanvasRenderingContext2D", identifier.propagatedType.name);
+    expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
   }
 
   void test_finalPropertyInducingVariable_classMember_instance() {
     addNamedSource("/lib.dart", r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(A a) {
@@ skipping 75 matching lines @@
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e in", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(stringType, identifier.propagatedType);
+      expect(identifier.propagatedType, same(stringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e;", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(stringType, identifier.propagatedType);
+      expect(identifier.propagatedType, same(stringType));
     }
   }
 
   void test_functionExpression_asInvocationArgument() {
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   m.forEach((k, v) {
     k;
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
+    expect(kParameter.identifier.propagatedType, same(intType));
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
+    expect(kIdentifier.propagatedType, same(intType));
+    expect(kIdentifier.staticType, same(typeProvider.dynamicType));
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+    expect(vParameter.identifier.propagatedType, same(stringType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
+    expect(vIdentifier.propagatedType, same(stringType));
+    expect(vIdentifier.staticType, same(typeProvider.dynamicType));
   }
 
   void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
     String code = r'''
 class MyMap<K, V> {
   forEach(f(K key, V value)) {}
 }
 f(MyMap<int, String> m) {
   var m2 = m;
   m2.forEach((k, v) {});
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
+    expect(kParameter.identifier.propagatedType, same(intType));
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+    expect(vParameter.identifier.propagatedType, same(stringType));
   }
 
   void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType dynamicType = typeProvider.dynamicType;
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is FormalParameter);
-    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
-    JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
+    expect(vParameter.identifier.propagatedType, same(stringType));
+    expect(vParameter.identifier.staticType, same(dynamicType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
-    JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
+    expect(vIdentifier.propagatedType, same(stringType));
+    expect(vIdentifier.staticType, same(dynamicType));
   }
 
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
     String code = r'''
 class MyList {
   forEach(f(Object value)) {}
 }
 f(MyList list) {
   list.forEach((int v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
-    JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
+    expect(vParameter.identifier.propagatedType, same(null));
+    expect(vParameter.identifier.staticType, same(intType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertSame(intType, vIdentifier.staticType);
-    JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
+    expect(vIdentifier.staticType, same(intType));
+    expect(vIdentifier.propagatedType, same(null));
   }
 
   void test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() {
     String code = r'''
 class A {
   m(void f(int i)) {}
 }
 x() {
   A a = new A();
   a.m(() => 0);
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // () => 0
     FunctionExpression functionExpression = EngineTestCase.findNode(unit, code, "() => 0)", (node) => node is FunctionExpression);
-    JUnitTestCase.assertSame(0, (functionExpression.staticType as FunctionType).parameters.length);
-    JUnitTestCase.assertSame(null, functionExpression.propagatedType);
+    expect((functionExpression.staticType as FunctionType).parameters.length, same(0));
+    expect(functionExpression.propagatedType, same(null));
   }
 
   void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
     String code = r'''
 class MyList<E> {
   forEach(f(E value)) {}
 }
 f(MyList<String> list) {
   list.forEach((Object v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
-    JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
+    expect(vParameter.identifier.propagatedType, same(stringType));
+    expect(vParameter.identifier.staticType, same(typeProvider.objectType));
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
-    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
+    expect(vIdentifier.propagatedType, same(stringType));
   }
 
   void test_Future_then() {
     String code = r'''
 import 'dart:async';
 main(Future<int> firstFuture) {
   firstFuture.then((p1) {
     return 1.0;
   }).then((p2) {
     return new Future<String>.value('str');
   }).then((p3) {
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // p1
     FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
+    expect(p1.identifier.propagatedType, same(typeProvider.intType));
     // p2
     FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
+    expect(p2.identifier.propagatedType, same(typeProvider.doubleType));
     // p3
     FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", (node) => node is SimpleFormalParameter);
-    JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
+    expect(p3.identifier.propagatedType, same(typeProvider.stringType));
   }
 
   void test_initializer() {
     Source source = addSource(r'''
 f() {
   var v = 0;
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
-      JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
-      JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+      expect(variableName.staticType, same(typeProvider.dynamicType));
+      expect(variableName.propagatedType, same(typeProvider.intType));
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-      JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
+      expect(variableName.propagatedType, same(typeProvider.intType));
     }
   }
 
   void test_initializer_dereference() {
     Source source = addSource(r'''
 f() {
   var v = 'String';
   v.
 }''');
     LibraryElement library = resolve(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement = body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
-    JUnitTestCase.assertSame(typeProvider.stringType, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeProvider.stringType));
   }
 
   void test_initializer_null() {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve(source);
       assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = null;", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
-      JUnitTestCase.assertSame(null, identifier.propagatedType);
+      expect(identifier.staticType, same(typeProvider.intType));
+      expect(identifier.propagatedType, same(null));
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // marker", (node) => node is SimpleIdentifier);
-      JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
-      JUnitTestCase.assertSame(null, identifier.propagatedType);
+      expect(identifier.staticType, same(typeProvider.intType));
+      expect(identifier.propagatedType, same(null));
     }
   }
 
   void test_is_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.thenExpression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_if_lessSpecific() {
     Source source = addSource(r'''
 class A {}
 A f(A p) {
   if (p is String) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     //    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
     //    InterfaceType typeA = classA.getElement().getType();
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(null, variableName.propagatedType);
+    expect(variableName.propagatedType, same(null));
   }
 
   void test_is_if_logicalAnd() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A && p != null) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is A) ? p : throw null;
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     A a = p;
   } else {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_subclass() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   B m() => this;
 }
 A f(A p) {
   if (p is B) {
     return p.m();
   }
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
-    JUnitTestCase.assertNotNull(invocation.methodName.propagatedElement);
+    expect(invocation.methodName.propagatedElement, isNotNull);
   }
 
   void test_is_while() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   while (p is A) {
     return p;
   }
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement = (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.elseExpression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_if_logicalOr() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A || null == p) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is! A) ? throw null : p;
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-    JUnitTestCase.assertSame(typeA, variableName.propagatedType);
+    expect(variableName.propagatedType, same(typeA));
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_2() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     enableUnionTypes(false);
     String code = r'''
 f(var message) {
   if (message is Function) {
     message = '';
   }
   message; // marker
 }''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
-    JUnitTestCase.assertFalse(typeProvider.stringType == t);
-    JUnitTestCase.assertFalse(typeProvider.functionType == t);
+    expect(typeProvider.stringType == t, isFalse);
+    expect(typeProvider.functionType == t, isFalse);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_5() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // This is not an example of the 20904 bug, but rather,
     // an example of something that one obvious fix changes inadvertently: we
     // want to avoid using type information from is-checks when it
     // loses precision. I can't see how to get a bad hint this way, since
     // it seems the propagated type is not used to generate hints when a
@@ skipping 49 matching lines @@
   return v[2];
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
-    JUnitTestCase.assertNull(indexExpression.propagatedType);
+    expect(indexExpression.propagatedType, isNull);
   }
 
   void test_listLiteral_same() {
     Source source = addSource(r'''
 f() {
   var v = [0, 1, 2];
   return v[2];
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
-    JUnitTestCase.assertNull(indexExpression.propagatedType);
+    expect(indexExpression.propagatedType, isNull);
     Expression v = indexExpression.target;
     InterfaceType propagatedType = v.propagatedType as InterfaceType;
-    JUnitTestCase.assertSame(typeProvider.listType.element, propagatedType.element);
+    expect(propagatedType.element, same(typeProvider.listType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(1, typeArguments);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
+    expect(typeArguments[0], same(typeProvider.dynamicType));
   }
 
   void test_mapLiteral_different() {
     Source source = addSource(r'''
 f() {
   var v = {'0' : 0, 1 : '1', '2' : 2};
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
-    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
+    expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
+    expect(typeArguments[0], same(typeProvider.dynamicType));
+    expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   void test_mapLiteral_same() {
     Source source = addSource(r'''
 f() {
   var v = {'a' : 0, 'b' : 1, 'c' : 2};
   return v;
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
-    JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
+    expect(propagatedType.element, same(typeProvider.mapType.element));
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
-    JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
+    expect(typeArguments[0], same(typeProvider.dynamicType));
+    expect(typeArguments[1], same(typeProvider.dynamicType));
   }
 
   void test_mergePropagatedTypesAtJoinPoint_4() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     _assertTypeOfMarkedExpression(r'''
 f5(x) {
   var y = [];
   if (x) {
     y = 0;
   } else {
@@ skipping 20 matching lines @@
   L: 
   if (c) {
   } else {
     x = '';
     c = true;
     break L;
   }
   x; // marker
 }''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
-    JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
-    JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
+    expect(typeProvider.intType.isSubtypeOf(t), isTrue);
+    expect(typeProvider.stringType.isSubtypeOf(t), isTrue);
   }
 
   void test_objectMethodOnDynamicExpression_doubleEquals() {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
     _assertTypeOfMarkedExpression(r'''
@@ skipping 120 matching lines @@
   return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];
 }''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements = (statement.expression as ListLiteral).elements;
-    JUnitTestCase.assertEquals("AnchorElement", elements[0].propagatedType.name);
-    JUnitTestCase.assertEquals("AnchorElement", elements[1].propagatedType.name);
-    JUnitTestCase.assertEquals("BodyElement", elements[2].propagatedType.name);
-    JUnitTestCase.assertEquals("ButtonElement", elements[3].propagatedType.name);
-    JUnitTestCase.assertEquals("DivElement", elements[4].propagatedType.name);
-    JUnitTestCase.assertEquals("InputElement", elements[5].propagatedType.name);
-    JUnitTestCase.assertEquals("SelectElement", elements[6].propagatedType.name);
-    JUnitTestCase.assertEquals("DivElement", elements[7].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements[8].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements[9].propagatedType.name);
-    JUnitTestCase.assertEquals("Element", elements[10].propagatedType.name);
+    expect(elements[0].propagatedType.name, "AnchorElement");
+    expect(elements[1].propagatedType.name, "AnchorElement");
+    expect(elements[2].propagatedType.name, "BodyElement");
+    expect(elements[3].propagatedType.name, "ButtonElement");
+    expect(elements[4].propagatedType.name, "DivElement");
+    expect(elements[5].propagatedType.name, "InputElement");
+    expect(elements[6].propagatedType.name, "SelectElement");
+    expect(elements[7].propagatedType.name, "DivElement");
+    expect(elements[8].propagatedType.name, "Element");
+    expect(elements[9].propagatedType.name, "Element");
+    expect(elements[10].propagatedType.name, "Element");
   }
 
   /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
   void _assertPropagatedReturnType(String code, DartType expectedStaticType, DartType expectedPropagatedType) {
     SimpleIdentifier identifier = _findMarkedIdentifier(code, "v = ");
-    JUnitTestCase.assertSame(expectedStaticType, identifier.staticType);
-    JUnitTestCase.assertSame(expectedPropagatedType, identifier.propagatedType);
+    expect(identifier.staticType, same(expectedStaticType));
+    expect(identifier.propagatedType, same(expectedPropagatedType));
   }
 
   /**
    * Check the static and propagated types of the expression marked with "; // marker" comment.
    *
    * @param code source code to analyze, with the expression to check marked with "// marker".
    * @param expectedStaticType if non-null, check actual static type is equal to this.
    * @param expectedPropagatedType if non-null, check actual static type is equal to this.
    * @throws Exception
    */
   void _assertTypeOfMarkedExpression(String code, DartType expectedStaticType, DartType expectedPropagatedType) {
     SimpleIdentifier identifier = _findMarkedIdentifier(code, "; // marker");
     if (expectedStaticType != null) {
-      JUnitTestCase.assertEquals(expectedStaticType, identifier.staticType);
+      expect(identifier.staticType, expectedStaticType);
     }
     if (expectedPropagatedType != null) {
-      JUnitTestCase.assertEquals(expectedPropagatedType, identifier.propagatedType);
+      expect(identifier.propagatedType, expectedPropagatedType);
     }
   }
 
   /**
    * Return the `SimpleIdentifier` marked by `marker`. The source code must have no
    * errors and be verifiable.
    *
    * @param code source code to analyze.
    * @param marker marker identifying sought after expression in source code.
    * @return expression marked by the marker.
@@ skipping 49 matching lines @@
         stackTraceType.element,
         stringType.element,
         symbolType.element,
         typeType.element];
     LibraryElementImpl coreLibrary = new LibraryElementImpl.forNode(new AnalysisContextImpl(), AstFactory.libraryIdentifier2(["dart.core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     //
     // Create a type provider and ensure that it can return the expected types.
     //
     TypeProviderImpl provider = new TypeProviderImpl(coreLibrary);
-    JUnitTestCase.assertSame(boolType, provider.boolType);
-    JUnitTestCase.assertNotNull(provider.bottomType);
-    JUnitTestCase.assertSame(doubleType, provider.doubleType);
-    JUnitTestCase.assertNotNull(provider.dynamicType);
-    JUnitTestCase.assertSame(functionType, provider.functionType);
-    JUnitTestCase.assertSame(intType, provider.intType);
-    JUnitTestCase.assertSame(listType, provider.listType);
-    JUnitTestCase.assertSame(mapType, provider.mapType);
-    JUnitTestCase.assertSame(objectType, provider.objectType);
-    JUnitTestCase.assertSame(stackTraceType, provider.stackTraceType);
-    JUnitTestCase.assertSame(stringType, provider.stringType);
-    JUnitTestCase.assertSame(symbolType, provider.symbolType);
-    JUnitTestCase.assertSame(typeType, provider.typeType);
+    expect(provider.boolType, same(boolType));
+    expect(provider.bottomType, isNotNull);
+    expect(provider.doubleType, same(doubleType));
+    expect(provider.dynamicType, isNotNull);
+    expect(provider.functionType, same(functionType));
+    expect(provider.intType, same(intType));
+    expect(provider.listType, same(listType));
+    expect(provider.mapType, same(mapType));
+    expect(provider.objectType, same(objectType));
+    expect(provider.stackTraceType, same(stackTraceType));
+    expect(provider.stringType, same(stringType));
+    expect(provider.symbolType, same(symbolType));
+    expect(provider.typeType, same(typeType));
   }
 
   ClassElement _classElement(String typeName, InterfaceType superclassType, List<String> parameterNames) {
     ClassElementImpl element = new ClassElementImpl.forNode(AstFactory.identifier3(typeName));
     element.supertype = superclassType;
     InterfaceTypeImpl type = new InterfaceTypeImpl.con1(element);
     element.type = type;
     int count = parameterNames.length;
     if (count > 0) {
       List<TypeParameterElementImpl> typeParameters = new List<TypeParameterElementImpl>(count);
@@ skipping 32 matching lines @@
    * The visitor used to resolve types needed to form the type hierarchy.
    */
   TypeResolverVisitor _visitor;
 
   /**
    * The visitor used to resolve types needed to form the type hierarchy.
    */
   ImplicitConstructorBuilder _implicitConstructorBuilder;
 
   void fail_visitConstructorDeclaration() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionDeclaration() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionTypeAlias() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitFunctionTypedFormalParameter() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitMethodDeclaration() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     _listener.assertNoErrors();
   }
 
   void fail_visitVariableDeclaration() {
-    JUnitTestCase.fail("Not yet tested");
+    fail("Not yet tested");
     ClassElement type = ElementFactory.classElement2("A", []);
     VariableDeclaration node = AstFactory.variableDeclaration("a");
     AstFactory.variableDeclarationList(null, AstFactory.typeName(type, []), [node]);
     //resolve(node);
-    JUnitTestCase.assertSame(type.type, node.name.staticType);
+    expect(node.name.staticType, same(type.type));
     _listener.assertNoErrors();
   }
 
   @override
   void setUp() {
     _listener = new GatheringErrorListener();
     SourceFactory factory = new SourceFactory([new FileUriResolver()]);
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = factory;
     Source librarySource = new FileBasedSource.con1(FileUtilities2.createFile("/lib.dart"));
@@ skipping 59 matching lines @@
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementB, []));
     WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
     ClassDeclaration declaration = AstFactory.classDeclaration(null, "A", null, extendsClause, withClause, implementsClause, []);
     declaration.name.staticElement = elementA;
     _resolveNode(declaration, [elementA, elementB, elementC, elementD]);
-    JUnitTestCase.assertSame(elementB.type, elementA.supertype);
+    expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     EngineTestCase.assertLength(1, mixins);
-    JUnitTestCase.assertSame(elementC.type, mixins[0]);
+    expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     EngineTestCase.assertLength(1, interfaces);
-    JUnitTestCase.assertSame(elementD.type, interfaces[0]);
+    expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitClassDeclaration_instanceMemberCollidesWithClass() {
     // class A {}
     // class B extends A {
     //   void A() {}
     // }
     ClassElementImpl elementA = ElementFactory.classElement2("A", []);
     ClassElementImpl elementB = ElementFactory.classElement2("B", []);
     elementB.methods = <MethodElement> [ElementFactory.methodElement("A", VoidTypeImpl.instance, [])];
     ExtendsClause extendsClause = AstFactory.extendsClause(AstFactory.typeName(elementA, []));
     ClassDeclaration declaration = AstFactory.classDeclaration(null, "B", null, extendsClause, null, null, []);
     declaration.name.staticElement = elementB;
     _resolveNode(declaration, [elementA, elementB]);
-    JUnitTestCase.assertSame(elementA.type, elementB.supertype);
+    expect(elementB.supertype, same(elementA.type));
     _listener.assertNoErrors();
   }
 
   void test_visitClassTypeAlias() {
     // class A = B with C implements D;
     ClassElement elementA = ElementFactory.classElement2("A", []);
     ClassElement elementB = ElementFactory.classElement2("B", []);
     ClassElement elementC = ElementFactory.classElement2("C", []);
     ClassElement elementD = ElementFactory.classElement2("D", []);
     WithClause withClause = AstFactory.withClause([AstFactory.typeName(elementC, [])]);
     ImplementsClause implementsClause = AstFactory.implementsClause([AstFactory.typeName(elementD, [])]);
     ClassTypeAlias alias = AstFactory.classTypeAlias("A", null, null, AstFactory.typeName(elementB, []), withClause, implementsClause);
     alias.name.staticElement = elementA;
     _resolveNode(alias, [elementA, elementB, elementC, elementD]);
-    JUnitTestCase.assertSame(elementB.type, elementA.supertype);
+    expect(elementA.supertype, same(elementB.type));
     List<InterfaceType> mixins = elementA.mixins;
     EngineTestCase.assertLength(1, mixins);
-    JUnitTestCase.assertSame(elementC.type, mixins[0]);
+    expect(mixins[0], same(elementC.type));
     List<InterfaceType> interfaces = elementA.interfaces;
     EngineTestCase.assertLength(1, interfaces);
-    JUnitTestCase.assertSame(elementD.type, interfaces[0]);
+    expect(interfaces[0], same(elementD.type));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_functionType() {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstFactory.typeName4("int", []);
     String innerParameterName = "a";
     SimpleFormalParameter parameter = AstFactory.simpleFormalParameter3(innerParameterName);
     parameter.identifier.staticElement = ElementFactory.requiredParameter(innerParameterName);
     String outerParameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(null, intTypeName, outerParameterName, AstFactory.formalParameterList([parameter]));
     node.identifier.staticElement = ElementFactory.requiredParameter(outerParameterName);
     DartType parameterType = _resolveFormalParameter(node, [intType.element]);
     EngineTestCase.assertInstanceOf((obj) => obj is FunctionType, FunctionType, parameterType);
     FunctionType functionType = parameterType as FunctionType;
-    JUnitTestCase.assertSame(intType, functionType.returnType);
+    expect(functionType.returnType, same(intType));
     EngineTestCase.assertLength(1, functionType.parameters);
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_noType() {
     String parameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(Keyword.VAR, null, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
-    JUnitTestCase.assertSame(_typeProvider.dynamicType, _resolveFormalParameter(node, []));
+    expect(_resolveFormalParameter(node, []), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
   void test_visitFieldFormalParameter_type() {
     InterfaceType intType = _typeProvider.intType;
     TypeName intTypeName = AstFactory.typeName4("int", []);
     String parameterName = "p";
     FormalParameter node = AstFactory.fieldFormalParameter(null, intTypeName, parameterName);
     node.identifier.staticElement = ElementFactory.requiredParameter(parameterName);
-    JUnitTestCase.assertSame(intType, _resolveFormalParameter(node, [intType.element]));
+    expect(_resolveFormalParameter(node, [intType.element]), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_noType() {
     // p
     FormalParameter node = AstFactory.simpleFormalParameter3("p");
     node.identifier.staticElement = new ParameterElementImpl.forNode(AstFactory.identifier3("p"));
-    JUnitTestCase.assertSame(_typeProvider.dynamicType, _resolveFormalParameter(node, []));
+    expect(_resolveFormalParameter(node, []), same(_typeProvider.dynamicType));
     _listener.assertNoErrors();
   }
 
   void test_visitSimpleFormalParameter_type() {
     // int p
     InterfaceType intType = _typeProvider.intType;
     ClassElement intElement = intType.element;
     FormalParameter node = AstFactory.simpleFormalParameter4(AstFactory.typeName(intElement, []), "p");
     SimpleIdentifier identifier = node.identifier;
     ParameterElementImpl element = new ParameterElementImpl.forNode(identifier);
     identifier.staticElement = element;
-    JUnitTestCase.assertSame(intType, _resolveFormalParameter(node, [intElement]));
+    expect(_resolveFormalParameter(node, [intElement]), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_noParameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     TypeName typeName = AstFactory.typeName(classA, []);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
-    JUnitTestCase.assertSame(classA.type, typeName.type);
+    expect(typeName.type, same(classA.type));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_parameters_arguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classB = ElementFactory.classElement2("B", []);
     TypeName typeName = AstFactory.typeName(classA, [AstFactory.typeName(classB, [])]);
     typeName.type = null;
     _resolveNode(typeName, [classA, classB]);
     InterfaceType resultType = typeName.type as InterfaceType;
-    JUnitTestCase.assertSame(classA, resultType.element);
+    expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
-    JUnitTestCase.assertSame(classB.type, resultArguments[0]);
+    expect(resultArguments[0], same(classB.type));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_parameters_noArguments() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     TypeName typeName = AstFactory.typeName(classA, []);
     typeName.type = null;
     _resolveNode(typeName, [classA]);
     InterfaceType resultType = typeName.type as InterfaceType;
-    JUnitTestCase.assertSame(classA, resultType.element);
+    expect(resultType.element, same(classA));
     List<DartType> resultArguments = resultType.typeArguments;
     EngineTestCase.assertLength(1, resultArguments);
-    JUnitTestCase.assertSame(DynamicTypeImpl.instance, resultArguments[0]);
+    expect(resultArguments[0], same(DynamicTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   void test_visitTypeName_void() {
     ClassElement classA = ElementFactory.classElement2("A", []);
     TypeName typeName = AstFactory.typeName4("void", []);
     _resolveNode(typeName, [classA]);
-    JUnitTestCase.assertSame(VoidTypeImpl.instance, typeName.type);
+    expect(typeName.type, same(VoidTypeImpl.instance));
     _listener.assertNoErrors();
   }
 
   /**
    * Analyze the given catch clause and assert that the types of the parameters have been set to the
    * given types. The types can be null if the catch clause does not have the corresponding
    * parameter.
    *
    * @param node the catch clause to be analyzed
    * @param exceptionType the expected type of the exception parameter
    * @param stackTraceType the expected type of the stack trace parameter
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    */
   void _resolveCatchClause(CatchClause node, DartType exceptionType, InterfaceType stackTraceType, List<Element> definedElements) {
     _resolveNode(node, definedElements);
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
-      JUnitTestCase.assertSame(exceptionType, exceptionParameter.staticType);
+      expect(exceptionParameter.staticType, same(exceptionType));
     }
     SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
     if (stackTraceParameter != null) {
-      JUnitTestCase.assertSame(stackTraceType, stackTraceParameter.staticType);
+      expect(stackTraceParameter.staticType, same(stackTraceType));
     }
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
    *
    * @param node the parameter with which the type is associated
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
@@ skipping 16 matching lines @@
   void _resolveNode(AstNode node, List<Element> definedElements) {
     for (Element element in definedElements) {
       _library.libraryScope.define(element);
     }
     node.accept(_visitor);
     node.accept(_implicitConstructorBuilder);
   }
 }
 
 main() {
-  _ut.groupSep = ' | ';
+  groupSep = ' | ';
   runReflectiveTests(AnalysisDeltaTest);
   runReflectiveTests(ChangeSetTest);
   runReflectiveTests(EnclosedScopeTest);
   runReflectiveTests(LibraryImportScopeTest);
   runReflectiveTests(LibraryScopeTest);
   runReflectiveTests(ScopeBuilderTest);
   runReflectiveTests(ScopeTest);
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(ElementResolverTest);
   runReflectiveTests(IncrementalResolverTest);
@@ skipping 10 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }