pkg/analyzer/test/generated/element_test.dart - Issue 685573002: Inline JUnitTestCase 'assert' methods.

Unified Diff: pkg/analyzer/test/generated/element_test.dart

Issue 685573002: Inline JUnitTestCase 'assert' methods. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

« no previous file with comments | « pkg/analyzer/test/generated/ast_test.dart ('k') | pkg/analyzer/test/generated/engine_test.dart » ('j') | pkg/analyzer/test/generated/test_support.dart » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: pkg/analyzer/test/generated/element_test.dart

diff --git a/pkg/analyzer/test/generated/element_test.dart b/pkg/analyzer/test/generated/element_test.dart

index ed882a38599513747e86f0c0e0db4b854b59416a..d67c664f065e191d98e2fbb1c161ece28218321a 100644

--- a/pkg/analyzer/test/generated/element_test.dart

+++ b/pkg/analyzer/test/generated/element_test.dart

@@ -8,12 +8,11 @@

library engine.element_test;

import 'package:analyzer/src/generated/java_core.dart';

-import 'package:analyzer/src/generated/java_junit.dart';

import 'package:analyzer/src/generated/source_io.dart';

import 'package:analyzer/src/generated/ast.dart';

import 'package:analyzer/src/generated/element.dart';

import 'package:analyzer/src/generated/engine.dart' show AnalysisContext, AnalysisContextImpl;

-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';

@@ -25,32 +24,32 @@ import '../reflective_tests.dart';

class AngularPropertyKindTest extends EngineTestCase {

void test_ATTR() {

AngularPropertyKind kind = AngularPropertyKind.ATTR;

- JUnitTestCase.assertFalse(kind.callsGetter());

- JUnitTestCase.assertTrue(kind.callsSetter());

+ expect(kind.callsGetter(), isFalse);

+ expect(kind.callsSetter(), isTrue);

}

void test_CALLBACK() {

AngularPropertyKind kind = AngularPropertyKind.CALLBACK;

- JUnitTestCase.assertFalse(kind.callsGetter());

- JUnitTestCase.assertTrue(kind.callsSetter());

+ expect(kind.callsGetter(), isFalse);

+ expect(kind.callsSetter(), isTrue);

}

void test_ONE_WAY() {

AngularPropertyKind kind = AngularPropertyKind.ONE_WAY;

- JUnitTestCase.assertFalse(kind.callsGetter());

- JUnitTestCase.assertTrue(kind.callsSetter());

+ expect(kind.callsGetter(), isFalse);

+ expect(kind.callsSetter(), isTrue);

}

void test_ONE_WAY_ONE_TIME() {

AngularPropertyKind kind = AngularPropertyKind.ONE_WAY_ONE_TIME;

- JUnitTestCase.assertFalse(kind.callsGetter());

- JUnitTestCase.assertTrue(kind.callsSetter());

+ expect(kind.callsGetter(), isFalse);

+ expect(kind.callsSetter(), isTrue);

}

void test_TWO_WAY() {

AngularPropertyKind kind = AngularPropertyKind.TWO_WAY;

- JUnitTestCase.assertTrue(kind.callsGetter());

- JUnitTestCase.assertTrue(kind.callsSetter());

+ expect(kind.callsGetter(), isTrue);

+ expect(kind.callsSetter(), isTrue);

}

@@ -67,10 +66,10 @@ class ClassElementImplTest extends EngineTestCase {

List<InterfaceType> supers = elementC.allSupertypes;

List<InterfaceType> types = new List<InterfaceType>();

types.addAll(supers);

- JUnitTestCase.assertTrue(types.contains(typeA));

- JUnitTestCase.assertTrue(types.contains(typeB));

- JUnitTestCase.assertTrue(types.contains(typeObject));

- JUnitTestCase.assertFalse(types.contains(typeC));

+ expect(types.contains(typeA), isTrue);

+ expect(types.contains(typeB), isTrue);

+ expect(types.contains(typeObject), isTrue);

+ expect(types.contains(typeC), isFalse);

}

void test_getAllSupertypes_mixins() {

@@ -85,10 +84,10 @@ class ClassElementImplTest extends EngineTestCase {

List<InterfaceType> supers = classC.allSupertypes;

List<InterfaceType> types = new List<InterfaceType>();

types.addAll(supers);

- JUnitTestCase.assertFalse(types.contains(typeA));

- JUnitTestCase.assertTrue(types.contains(typeB));

- JUnitTestCase.assertTrue(types.contains(typeObject));

- JUnitTestCase.assertFalse(types.contains(typeC));

+ expect(types.contains(typeA), isFalse);

+ expect(types.contains(typeB), isTrue);

+ expect(types.contains(typeObject), isTrue);

+ expect(types.contains(typeC), isFalse);

}

void test_getAllSupertypes_recursive() {

@@ -104,9 +103,9 @@ class ClassElementImplTest extends EngineTestCase {

String fieldName = "f";

FieldElementImpl field = ElementFactory.fieldElement(fieldName, false, false, false, null);

classA.fields = <FieldElement> [field];

- JUnitTestCase.assertSame(field, classA.getField(fieldName));

+ expect(classA.getField(fieldName), same(field));

// no such field

- JUnitTestCase.assertSame(null, classA.getField("noSuchField"));

+ expect(classA.getField("noSuchField"), same(null));

}

void test_getMethod_declared() {

@@ -114,7 +113,7 @@ class ClassElementImplTest extends EngineTestCase {

String methodName = "m";

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

- JUnitTestCase.assertSame(method, classA.getMethod(methodName));

+ expect(classA.getMethod(methodName), same(method));

}

void test_getMethod_undeclared() {

@@ -122,7 +121,7 @@ class ClassElementImplTest extends EngineTestCase {

String methodName = "m";

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

- JUnitTestCase.assertNull(classA.getMethod("${methodName}x"));

+ expect(classA.getMethod("${methodName}x"), isNull);

}

void test_getNode() {

@@ -138,70 +137,70 @@ class B {}''');

{

ClassElement elementA = unitElement.getType("A");

ClassDeclaration nodeA = elementA.node;

- JUnitTestCase.assertNotNull(nodeA);

- JUnitTestCase.assertEquals("A", nodeA.name.name);

- JUnitTestCase.assertSame(elementA, nodeA.element);

+ expect(nodeA, isNotNull);

+ expect(nodeA.name.name, "A");

+ expect(nodeA.element, same(elementA));

}

// B

{

ClassElement elementB = unitElement.getType("B");

ClassDeclaration nodeB = elementB.node;

- JUnitTestCase.assertNotNull(nodeB);

- JUnitTestCase.assertEquals("B", nodeB.name.name);

- JUnitTestCase.assertSame(elementB, nodeB.element);

+ expect(nodeB, isNotNull);

+ expect(nodeB.name.name, "B");

+ expect(nodeB.element, same(elementB));

}

void test_hasNonFinalField_false_const() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, true, classA.type)];

- JUnitTestCase.assertFalse(classA.hasNonFinalField);

+ expect(classA.hasNonFinalField, isFalse);

}

void test_hasNonFinalField_false_final() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, true, false, classA.type)];

- JUnitTestCase.assertFalse(classA.hasNonFinalField);

+ expect(classA.hasNonFinalField, isFalse);

}

void test_hasNonFinalField_false_recursive() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

- JUnitTestCase.assertFalse(classA.hasNonFinalField);

+ expect(classA.hasNonFinalField, isFalse);

}

void test_hasNonFinalField_true_immediate() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, false, classA.type)];

- JUnitTestCase.assertTrue(classA.hasNonFinalField);

+ expect(classA.hasNonFinalField, isTrue);

}

void test_hasNonFinalField_true_inherited() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, false, classA.type)];

- JUnitTestCase.assertTrue(classB.hasNonFinalField);

+ expect(classB.hasNonFinalField, isTrue);

}

void test_hasStaticMember_false_empty() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

// no members

- JUnitTestCase.assertFalse(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isFalse);

}

void test_hasStaticMember_false_instanceMethod() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

MethodElement method = ElementFactory.methodElement("foo", null, []);

classA.methods = <MethodElement> [method];

- JUnitTestCase.assertFalse(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isFalse);

}

void test_hasStaticMember_instanceGetter() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

PropertyAccessorElement getter = ElementFactory.getterElement("foo", false, null);

classA.accessors = <PropertyAccessorElement> [getter];

- JUnitTestCase.assertFalse(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isFalse);

}

void test_hasStaticMember_true_getter() {

@@ -210,7 +209,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [getter];

// "foo" is static

getter.static = true;

- JUnitTestCase.assertTrue(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isTrue);

}

void test_hasStaticMember_true_method() {

@@ -219,7 +218,7 @@ class B {}''');

classA.methods = <MethodElement> [method];

// "foo" is static

method.static = true;

- JUnitTestCase.assertTrue(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isTrue);

}

void test_hasStaticMember_true_setter() {

@@ -228,7 +227,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [setter];

// "foo" is static

setter.static = true;

- JUnitTestCase.assertTrue(classA.hasStaticMember);

+ expect(classA.hasStaticMember, isTrue);

}

void test_lookUpConcreteMethod_declared() {

@@ -241,7 +240,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(method, classA.lookUpConcreteMethod(methodName, library));

+ expect(classA.lookUpConcreteMethod(methodName, library), same(method));

}

void test_lookUpConcreteMethod_declaredAbstract() {

@@ -255,7 +254,7 @@ class B {}''');

method.abstract = true;

classA.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpConcreteMethod(methodName, library));

+ expect(classA.lookUpConcreteMethod(methodName, library), isNull);

}

void test_lookUpConcreteMethod_declaredAbstractAndInherited() {

@@ -275,7 +274,7 @@ class B {}''');

method.abstract = true;

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpConcreteMethod(methodName, library));

+ expect(classB.lookUpConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpConcreteMethod_declaredAndInherited() {

@@ -294,7 +293,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(method, classB.lookUpConcreteMethod(methodName, library));

+ expect(classB.lookUpConcreteMethod(methodName, library), same(method));

}

void test_lookUpConcreteMethod_declaredAndInheritedAbstract() {

@@ -315,7 +314,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(method, classB.lookUpConcreteMethod(methodName, library));

+ expect(classB.lookUpConcreteMethod(methodName, library), same(method));

}

void test_lookUpConcreteMethod_inherited() {

@@ -331,7 +330,7 @@ class B {}''');

classA.methods = <MethodElement> [inheritedMethod];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpConcreteMethod(methodName, library));

+ expect(classB.lookUpConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpConcreteMethod_undeclared() {

@@ -340,7 +339,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpConcreteMethod("m", library));

+ expect(classA.lookUpConcreteMethod("m", library), isNull);

}

void test_lookUpGetter_declared() {

@@ -353,7 +352,7 @@ class B {}''');

PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, null);

classA.accessors = <PropertyAccessorElement> [getter];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(getter, classA.lookUpGetter(getterName, library));

+ expect(classA.lookUpGetter(getterName, library), same(getter));

}

void test_lookUpGetter_inherited() {

@@ -369,7 +368,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [getter];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(getter, classB.lookUpGetter(getterName, library));

+ expect(classB.lookUpGetter(getterName, library), same(getter));

}

void test_lookUpGetter_undeclared() {

@@ -378,7 +377,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpGetter("g", library));

+ expect(classA.lookUpGetter("g", library), isNull);

}

void test_lookUpGetter_undeclared_recursive() {

@@ -391,7 +390,7 @@ class B {}''');

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classA.lookUpGetter("g", library));

+ expect(classA.lookUpGetter("g", library), isNull);

}

void test_lookUpInheritedConcreteGetter_declared() {

@@ -404,7 +403,7 @@ class B {}''');

PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, null);

classA.accessors = <PropertyAccessorElement> [getter];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteGetter(getterName, library));

+ expect(classA.lookUpInheritedConcreteGetter(getterName, library), isNull);

}

void test_lookUpInheritedConcreteGetter_inherited() {

@@ -420,7 +419,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [inheritedGetter];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedGetter, classB.lookUpInheritedConcreteGetter(getterName, library));

+ expect(classB.lookUpInheritedConcreteGetter(getterName, library), same(inheritedGetter));

}

void test_lookUpInheritedConcreteGetter_undeclared() {

@@ -429,7 +428,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteGetter("g", library));

+ expect(classA.lookUpInheritedConcreteGetter("g", library), isNull);

}

void test_lookUpInheritedConcreteGetter_undeclared_recursive() {

@@ -442,7 +441,7 @@ class B {}''');

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteGetter("g", library));

+ expect(classA.lookUpInheritedConcreteGetter("g", library), isNull);

}

void test_lookUpInheritedConcreteMethod_declared() {

@@ -455,7 +454,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classA.lookUpInheritedConcreteMethod(methodName, library), isNull);

}

void test_lookUpInheritedConcreteMethod_declaredAbstractAndInherited() {

@@ -475,7 +474,7 @@ class B {}''');

method.abstract = true;

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classB.lookUpInheritedConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedConcreteMethod_declaredAndInherited() {

@@ -494,7 +493,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classB.lookUpInheritedConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedConcreteMethod_declaredAndInheritedAbstract() {

@@ -515,7 +514,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classB.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classB.lookUpInheritedConcreteMethod(methodName, library), isNull);

}

void test_lookUpInheritedConcreteMethod_declaredAndInheritedWithAbstractBetween() {

@@ -541,7 +540,7 @@ class B {}''');

MethodElementImpl method = ElementFactory.methodElement(methodName, null, []);

classC.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB, classC];

- JUnitTestCase.assertSame(inheritedMethod, classC.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classC.lookUpInheritedConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedConcreteMethod_inherited() {

@@ -557,7 +556,7 @@ class B {}''');

classA.methods = <MethodElement> [inheritedMethod];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpInheritedConcreteMethod(methodName, library));

+ expect(classB.lookUpInheritedConcreteMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedConcreteMethod_undeclared() {

@@ -566,7 +565,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteMethod("m", library));

+ expect(classA.lookUpInheritedConcreteMethod("m", library), isNull);

}

void test_lookUpInheritedConcreteSetter_declared() {

@@ -579,7 +578,7 @@ class B {}''');

PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, null);

classA.accessors = <PropertyAccessorElement> [setter];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteSetter(setterName, library));

+ expect(classA.lookUpInheritedConcreteSetter(setterName, library), isNull);

}

void test_lookUpInheritedConcreteSetter_inherited() {

@@ -595,7 +594,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [setter];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(setter, classB.lookUpInheritedConcreteSetter(setterName, library));

+ expect(classB.lookUpInheritedConcreteSetter(setterName, library), same(setter));

}

void test_lookUpInheritedConcreteSetter_undeclared() {

@@ -604,7 +603,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteSetter("s", library));

+ expect(classA.lookUpInheritedConcreteSetter("s", library), isNull);

}

void test_lookUpInheritedConcreteSetter_undeclared_recursive() {

@@ -617,7 +616,7 @@ class B {}''');

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classA.lookUpInheritedConcreteSetter("s", library));

+ expect(classA.lookUpInheritedConcreteSetter("s", library), isNull);

}

void test_lookUpInheritedMethod_declared() {

@@ -630,7 +629,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedMethod(methodName, library));

+ expect(classA.lookUpInheritedMethod(methodName, library), isNull);

}

void test_lookUpInheritedMethod_declaredAndInherited() {

@@ -649,7 +648,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classB.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpInheritedMethod(methodName, library));

+ expect(classB.lookUpInheritedMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedMethod_inherited() {

@@ -665,7 +664,7 @@ class B {}''');

classA.methods = <MethodElement> [inheritedMethod];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(inheritedMethod, classB.lookUpInheritedMethod(methodName, library));

+ expect(classB.lookUpInheritedMethod(methodName, library), same(inheritedMethod));

}

void test_lookUpInheritedMethod_undeclared() {

@@ -674,7 +673,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpInheritedMethod("m", library));

+ expect(classA.lookUpInheritedMethod("m", library), isNull);

}

void test_lookUpMethod_declared() {

@@ -684,7 +683,7 @@ class B {}''');

MethodElement method = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [method];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(method, classA.lookUpMethod(methodName, library));

+ expect(classA.lookUpMethod(methodName, library), same(method));

}

void test_lookUpMethod_inherited() {

@@ -695,14 +694,14 @@ class B {}''');

classA.methods = <MethodElement> [method];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(method, classB.lookUpMethod(methodName, library));

+ expect(classB.lookUpMethod(methodName, library), same(method));

}

void test_lookUpMethod_undeclared() {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpMethod("m", library));

+ expect(classA.lookUpMethod("m", library), isNull);

}

void test_lookUpMethod_undeclared_recursive() {

@@ -711,7 +710,7 @@ class B {}''');

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classA.lookUpMethod("m", library));

+ expect(classA.lookUpMethod("m", library), isNull);

}

void test_lookUpSetter_declared() {

@@ -724,7 +723,7 @@ class B {}''');

PropertyAccessorElement setter = ElementFactory.setterElement(setterName, false, null);

classA.accessors = <PropertyAccessorElement> [setter];

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(setter, classA.lookUpSetter(setterName, library));

+ expect(classA.lookUpSetter(setterName, library), same(setter));

}

void test_lookUpSetter_inherited() {

@@ -740,7 +739,7 @@ class B {}''');

classA.accessors = <PropertyAccessorElement> [setter];

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(setter, classB.lookUpSetter(setterName, library));

+ expect(classB.lookUpSetter(setterName, library), same(setter));

}

void test_lookUpSetter_undeclared() {

@@ -749,7 +748,7 @@ class B {}''');

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElementImpl classA = ElementFactory.classElement2("A", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(classA.lookUpSetter("s", library));

+ expect(classA.lookUpSetter("s", library), isNull);

}

void test_lookUpSetter_undeclared_recursive() {

@@ -762,7 +761,7 @@ class B {}''');

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(classA.lookUpSetter("s", library));

+ expect(classA.lookUpSetter("s", library), isNull);

}

@@ -773,7 +772,7 @@ class CompilationUnitElementImplTest extends EngineTestCase {

String enumName = "E";

ClassElement enumElement = ElementFactory.enumElement(typeProvider, enumName, []);

unit.enums = <ClassElement> [enumElement];

- JUnitTestCase.assertSame(enumElement, unit.getEnum(enumName));

+ expect(unit.getEnum(enumName), same(enumElement));

}

void test_getEnum_undeclared() {

@@ -782,7 +781,7 @@ class CompilationUnitElementImplTest extends EngineTestCase {

String enumName = "E";

ClassElement enumElement = ElementFactory.enumElement(typeProvider, enumName, []);

unit.enums = <ClassElement> [enumElement];

- JUnitTestCase.assertNull(unit.getEnum("${enumName}x"));

+ expect(unit.getEnum("${enumName}x"), isNull);

}

void test_getType_declared() {

@@ -790,7 +789,7 @@ class CompilationUnitElementImplTest extends EngineTestCase {

String className = "C";

ClassElement classElement = ElementFactory.classElement2(className, []);

unit.types = <ClassElement> [classElement];

- JUnitTestCase.assertSame(classElement, unit.getType(className));

+ expect(unit.getType(className), same(classElement));

}

void test_getType_undeclared() {

@@ -798,7 +797,7 @@ class CompilationUnitElementImplTest extends EngineTestCase {

String className = "C";

ClassElement classElement = ElementFactory.classElement2(className, []);

unit.types = <ClassElement> [classElement];

- JUnitTestCase.assertNull(unit.getType("${className}x"));

+ expect(unit.getType("${className}x"), isNull);

}

@@ -809,10 +808,10 @@ class ElementImplTest extends EngineTestCase {

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];

FieldElement field = ElementFactory.fieldElement("next", false, false, false, classElement.type);

classElement.fields = <FieldElement> [field];

- JUnitTestCase.assertTrue(field == field);

- JUnitTestCase.assertFalse(field == field.getter);

- JUnitTestCase.assertFalse(field == field.setter);

- JUnitTestCase.assertFalse(field.getter == field.setter);

+ expect(field == field, isTrue);

+ expect(field == field.getter, isFalse);

+ expect(field == field.setter, isFalse);

+ expect(field.getter == field.setter, isFalse);

}

void test_isAccessibleIn_private_differentLibrary() {

@@ -821,14 +820,14 @@ class ElementImplTest extends EngineTestCase {

ClassElement classElement = ElementFactory.classElement2("_C", []);

(library1.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];

LibraryElementImpl library2 = ElementFactory.library(context, "lib2");

- JUnitTestCase.assertFalse(classElement.isAccessibleIn(library2));

+ expect(classElement.isAccessibleIn(library2), isFalse);

}

void test_isAccessibleIn_private_sameLibrary() {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElement classElement = ElementFactory.classElement2("_C", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];

- JUnitTestCase.assertTrue(classElement.isAccessibleIn(library));

+ expect(classElement.isAccessibleIn(library), isTrue);

}

void test_isAccessibleIn_public_differentLibrary() {

@@ -837,44 +836,44 @@ class ElementImplTest extends EngineTestCase {

ClassElement classElement = ElementFactory.classElement2("C", []);

(library1.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];

LibraryElementImpl library2 = ElementFactory.library(context, "lib2");

- JUnitTestCase.assertTrue(classElement.isAccessibleIn(library2));

+ expect(classElement.isAccessibleIn(library2), isTrue);

}

void test_isAccessibleIn_public_sameLibrary() {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

ClassElement classElement = ElementFactory.classElement2("C", []);

(library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];

- JUnitTestCase.assertTrue(classElement.isAccessibleIn(library));

+ expect(classElement.isAccessibleIn(library), isTrue);

}

void test_isPrivate_false() {

Element element = ElementFactory.classElement2("C", []);

- JUnitTestCase.assertFalse(element.isPrivate);

+ expect(element.isPrivate, isFalse);

}

void test_isPrivate_null() {

Element element = ElementFactory.classElement2(null, []);

- JUnitTestCase.assertTrue(element.isPrivate);

+ expect(element.isPrivate, isTrue);

}

void test_isPrivate_true() {

Element element = ElementFactory.classElement2("_C", []);

- JUnitTestCase.assertTrue(element.isPrivate);

+ expect(element.isPrivate, isTrue);

}

void test_isPublic_false() {

Element element = ElementFactory.classElement2("_C", []);

- JUnitTestCase.assertFalse(element.isPublic);

+ expect(element.isPublic, isFalse);

}

void test_isPublic_null() {

Element element = ElementFactory.classElement2(null, []);

- JUnitTestCase.assertFalse(element.isPublic);

+ expect(element.isPublic, isFalse);

}

void test_isPublic_true() {

Element element = ElementFactory.classElement2("C", []);

- JUnitTestCase.assertTrue(element.isPublic);

+ expect(element.isPublic, isTrue);

}

void test_SORT_BY_OFFSET() {

@@ -882,19 +881,19 @@ class ElementImplTest extends EngineTestCase {

classElementA.nameOffset = 1;

ClassElementImpl classElementB = ElementFactory.classElement2("B", []);

classElementB.nameOffset = 2;

- JUnitTestCase.assertEquals(0, Element.SORT_BY_OFFSET(classElementA, classElementA));

- JUnitTestCase.assertTrue(Element.SORT_BY_OFFSET(classElementA, classElementB) < 0);

- JUnitTestCase.assertTrue(Element.SORT_BY_OFFSET(classElementB, classElementA) > 0);

+ expect(Element.SORT_BY_OFFSET(classElementA, classElementA), 0);

+ expect(Element.SORT_BY_OFFSET(classElementA, classElementB) < 0, isTrue);

+ expect(Element.SORT_BY_OFFSET(classElementB, classElementA) > 0, isTrue);

}

class ElementKindTest extends EngineTestCase {

void test_of_nonNull() {

- JUnitTestCase.assertSame(ElementKind.CLASS, ElementKind.of(ElementFactory.classElement2("A", [])));

+ expect(ElementKind.of(ElementFactory.classElement2("A", [])), same(ElementKind.CLASS));

}

void test_of_null() {

- JUnitTestCase.assertSame(ElementKind.ERROR, ElementKind.of(null));

+ expect(ElementKind.of(null), same(ElementKind.ERROR));

}

@@ -902,7 +901,7 @@ class ElementLocationImplTest extends EngineTestCase {

void test_create_encoding() {

String encoding = "a;b;c";

ElementLocationImpl location = new ElementLocationImpl.con2(encoding);

- JUnitTestCase.assertEquals(encoding, location.encoding);

+ expect(location.encoding, encoding);

}

/**

@@ -911,31 +910,31 @@ class ElementLocationImplTest extends EngineTestCase {

void test_create_encoding_emptyLast() {

String encoding = "a;b;c;";

ElementLocationImpl location = new ElementLocationImpl.con2(encoding);

- JUnitTestCase.assertEquals(encoding, location.encoding);

+ expect(location.encoding, encoding);

}

void test_equals_equal() {

String encoding = "a;b;c";

ElementLocationImpl first = new ElementLocationImpl.con2(encoding);

ElementLocationImpl second = new ElementLocationImpl.con2(encoding);

- JUnitTestCase.assertTrue(first == second);

+ expect(first == second, isTrue);

}

void test_equals_notEqual_differentLengths() {

ElementLocationImpl first = new ElementLocationImpl.con2("a;b;c");

ElementLocationImpl second = new ElementLocationImpl.con2("a;b;c;d");

- JUnitTestCase.assertFalse(first == second);

+ expect(first == second, isFalse);

}

void test_equals_notEqual_notLocation() {

ElementLocationImpl first = new ElementLocationImpl.con2("a;b;c");

- JUnitTestCase.assertFalse(first == "a;b;d");

+ expect(first == "a;b;d", isFalse);

}

void test_equals_notEqual_sameLengths() {

ElementLocationImpl first = new ElementLocationImpl.con2("a;b;c");

ElementLocationImpl second = new ElementLocationImpl.con2("a;b;d");

- JUnitTestCase.assertFalse(first == second);

+ expect(first == second, isFalse);

}

void test_getComponents() {

@@ -943,34 +942,34 @@ class ElementLocationImplTest extends EngineTestCase {

ElementLocationImpl location = new ElementLocationImpl.con2(encoding);

List<String> components = location.components;

EngineTestCase.assertLength(3, components);

- JUnitTestCase.assertEquals("a", components[0]);

- JUnitTestCase.assertEquals("b", components[1]);

- JUnitTestCase.assertEquals("c", components[2]);

+ expect(components[0], "a");

+ expect(components[1], "b");

+ expect(components[2], "c");

}

void test_getEncoding() {

String encoding = "a;b;c;;d";

ElementLocationImpl location = new ElementLocationImpl.con2(encoding);

- JUnitTestCase.assertEquals(encoding, location.encoding);

+ expect(location.encoding, encoding);

}

void test_hashCode_equal() {

String encoding = "a;b;c";

ElementLocationImpl first = new ElementLocationImpl.con2(encoding);

ElementLocationImpl second = new ElementLocationImpl.con2(encoding);

- JUnitTestCase.assertTrue(first.hashCode == second.hashCode);

+ expect(first.hashCode == second.hashCode, isTrue);

}

class FunctionTypeImplTest extends EngineTestCase {

void test_creation() {

- JUnitTestCase.assertNotNull(new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f"))));

+ expect(new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f"))), isNotNull);

}

void test_getElement() {

FunctionElementImpl typeElement = new FunctionElementImpl.forNode(AstFactory.identifier3("f"));

FunctionTypeImpl type = new FunctionTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(typeElement, type.element);

+ expect(type.element, typeElement);

}

void test_getNamedParameterTypes() {

@@ -991,7 +990,7 @@ class FunctionTypeImplTest extends EngineTestCase {

functionElement.returnType = expectedReturnType;

FunctionTypeImpl type = new FunctionTypeImpl.con1(functionElement);

DartType returnType = type.returnType;

- JUnitTestCase.assertEquals(expectedReturnType, returnType);

+ expect(returnType, expectedReturnType);

}

void test_getTypeArguments() {

@@ -1015,11 +1014,11 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [a]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isFalse);

// assignable iff subtype

- JUnitTestCase.assertTrue(t.isAssignableTo(s));

- JUnitTestCase.assertFalse(s.isAssignableTo(t));

+ expect(t.isAssignableTo(s), isTrue);

+ expect(s.isAssignableTo(t), isFalse);

}

void test_isSubtypeOf_baseCase_classFunction() {

@@ -1027,7 +1026,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElementImpl functionElement = ElementFactory.classElement2("Function", []);

InterfaceTypeImpl functionType = new InterfaceTypeImpl_FunctionTypeImplTest_test_isSubtypeOf_baseCase_classFunction(functionElement);

FunctionType f = ElementFactory.functionElement("f").type;

- JUnitTestCase.assertTrue(f.isSubtypeOf(functionType));

+ expect(f.isSubtypeOf(functionType), isTrue);

}

void test_isSubtypeOf_baseCase_notFunctionType() {

@@ -1035,19 +1034,19 @@ class FunctionTypeImplTest extends EngineTestCase {

// ! () -> void <: C

FunctionType f = ElementFactory.functionElement("f").type;

InterfaceType t = ElementFactory.classElement2("C", []).type;

- JUnitTestCase.assertFalse(f.isSubtypeOf(t));

+ expect(f.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_baseCase_null() {

// ! () -> void <: null

FunctionType f = ElementFactory.functionElement("f").type;

- JUnitTestCase.assertFalse(f.isSubtypeOf(null));

+ expect(f.isSubtypeOf(null), isFalse);

}

void test_isSubtypeOf_baseCase_self() {

// () -> void <: () -> void

FunctionType f = ElementFactory.functionElement("f").type;

- JUnitTestCase.assertTrue(f.isSubtypeOf(f));

+ expect(f.isSubtypeOf(f), isTrue);

}

void test_isSubtypeOf_namedParameters_isAssignable() {

@@ -1058,15 +1057,15 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["name"], <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["name"], <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertTrue(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isTrue);

}

void test_isSubtypeOf_namedParameters_isNotAssignable() {

// ! ({name: A}) -> void <: ({name: B}) -> void

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["name"], <ClassElement> [ElementFactory.classElement2("A", [])]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["name"], <ClassElement> [ElementFactory.classElement2("B", [])]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_namedParameters_namesDifferent() {

@@ -1079,8 +1078,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["name"], <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["diff"], <ClassElement> [b]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isFalse);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_namedParameters_orderOfParams() {

@@ -1090,7 +1089,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["A", "B"], <ClassElement> [a, b]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["B", "A"], <ClassElement> [b, a]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isTrue);

}

void test_isSubtypeOf_namedParameters_orderOfParams2() {

@@ -1100,7 +1099,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["B"], <ClassElement> [b]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["B", "A"], <ClassElement> [b, a]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_namedParameters_orderOfParams3() {

@@ -1110,7 +1109,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["A", "B"], <ClassElement> [a, b]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["B"], <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isTrue);

}

void test_isSubtypeOf_namedParameters_sHasMoreParams() {

@@ -1120,7 +1119,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["name"], <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["name", "name2"], <ClassElement> [b, b]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_namedParameters_tHasMoreParams() {

@@ -1130,7 +1129,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement4("t", null, null, <String> ["name", "name2"], <ClassElement> [a, a]).type;

FunctionType s = ElementFactory.functionElement4("s", null, null, <String> ["name"], <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isTrue);

}

void test_isSubtypeOf_normalAndPositionalArgs_1() {

@@ -1138,8 +1137,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [a]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_normalAndPositionalArgs_2() {

@@ -1147,8 +1146,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", <ClassElement> [a], <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [a]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_normalAndPositionalArgs_3() {

@@ -1156,8 +1155,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement("s").type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_normalAndPositionalArgs_4() {

@@ -1169,8 +1168,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement e = ElementFactory.classElement2("E", []);

FunctionType t = ElementFactory.functionElement6("t", <ClassElement> [a, b], <ClassElement> [c, d, e]).type;

FunctionType s = ElementFactory.functionElement6("s", <ClassElement> [a, b, c], <ClassElement> [d]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_normalParameters_isAssignable() {

@@ -1181,15 +1180,15 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertTrue(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isTrue);

}

void test_isSubtypeOf_normalParameters_isNotAssignable() {

// ! (a) -> void <: (b) -> void

FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [ElementFactory.classElement2("A", [])]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [ElementFactory.classElement2("B", [])]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_normalParameters_sHasMoreParams() {

@@ -1199,7 +1198,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [b, b]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_normalParameters_tHasMoreParams() {

@@ -1211,14 +1210,14 @@ class FunctionTypeImplTest extends EngineTestCase {

FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [b]).type;

// note, this is a different assertion from the other "tHasMoreParams" tests, this is

// intentional as it is a difference of the "normal parameters"

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_Object() {

// () -> void <: Object

FunctionType f = ElementFactory.functionElement("f").type;

InterfaceType t = ElementFactory.object.type;

- JUnitTestCase.assertTrue(f.isSubtypeOf(t));

+ expect(f.isSubtypeOf(t), isTrue);

}

void test_isSubtypeOf_positionalParameters_isAssignable() {

@@ -1229,15 +1228,15 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement6("s", null, <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertTrue(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isTrue);

}

void test_isSubtypeOf_positionalParameters_isNotAssignable() {

// ! ([a]) -> void <: ([b]) -> void

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [ElementFactory.classElement2("A", [])]).type;

FunctionType s = ElementFactory.functionElement6("s", null, <ClassElement> [ElementFactory.classElement2("B", [])]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_positionalParameters_sHasMoreParams() {

@@ -1247,7 +1246,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement6("s", null, <ClassElement> [b, b]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_positionalParameters_tHasMoreParams() {

@@ -1257,7 +1256,7 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a, a]).type;

FunctionType s = ElementFactory.functionElement6("s", null, <ClassElement> [b]).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isTrue);

}

void test_isSubtypeOf_returnType_sIsVoid() {

@@ -1265,8 +1264,8 @@ class FunctionTypeImplTest extends EngineTestCase {

FunctionType t = ElementFactory.functionElement("t").type;

FunctionType s = ElementFactory.functionElement("s").type;

// function s has the implicit return type of void, we assert it here

- JUnitTestCase.assertTrue(VoidTypeImpl.instance == s.returnType);

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

+ expect(VoidTypeImpl.instance == s.returnType, isTrue);

+ expect(t.isSubtypeOf(s), isTrue);

}

void test_isSubtypeOf_returnType_tAssignableToS() {

@@ -1277,15 +1276,15 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement b = ElementFactory.classElement("B", a.type, []);

FunctionType t = ElementFactory.functionElement2("t", a).type;

FunctionType s = ElementFactory.functionElement2("s", b).type;

- JUnitTestCase.assertTrue(t.isSubtypeOf(s));

- JUnitTestCase.assertTrue(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isTrue);

+ expect(s.isSubtypeOf(t), isTrue);

}

void test_isSubtypeOf_returnType_tNotAssignableToS() {

// ! () -> A <: () -> B

FunctionType t = ElementFactory.functionElement2("t", ElementFactory.classElement2("A", [])).type;

FunctionType s = ElementFactory.functionElement2("s", ElementFactory.classElement2("B", [])).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

+ expect(t.isSubtypeOf(s), isFalse);

}

void test_isSubtypeOf_typeParameters_matchesBounds() {

@@ -1312,7 +1311,7 @@ class FunctionTypeImplTest extends EngineTestCase {

functionElement.returnType = provider.dynamicType;

FunctionTypeImpl functionType = new FunctionTypeImpl.con1(functionElement);

functionElement.type = functionType;

- JUnitTestCase.assertTrue(functionType.isAssignableTo(functionAliasType));

+ expect(functionType.isAssignableTo(functionAliasType), isTrue);

}

void test_isSubtypeOf_wrongFunctionType_normal_named() {

@@ -1321,8 +1320,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement5("t", <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement7("s", null, <String> ["name"], <ClassElement> [a]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isFalse);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_isSubtypeOf_wrongFunctionType_optional_named() {

@@ -1331,8 +1330,8 @@ class FunctionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

FunctionType s = ElementFactory.functionElement7("s", null, <String> ["name"], <ClassElement> [a]).type;

- JUnitTestCase.assertFalse(t.isSubtypeOf(s));

- JUnitTestCase.assertFalse(s.isSubtypeOf(t));

+ expect(t.isSubtypeOf(s), isFalse);

+ expect(s.isSubtypeOf(t), isFalse);

}

void test_setTypeArguments() {

@@ -1344,7 +1343,7 @@ class FunctionTypeImplTest extends EngineTestCase {

type.typeArguments = <DartType> [expectedType];

List<DartType> arguments = type.typeArguments;

EngineTestCase.assertLength(1, arguments);

- JUnitTestCase.assertEquals(expectedType, arguments[0]);

+ expect(arguments[0], expectedType);

}

void test_substitute2_equal() {

@@ -1362,16 +1361,16 @@ class FunctionTypeImplTest extends EngineTestCase {

functionType.typeArguments = <DartType> [parameterType];

InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("D")));

FunctionType result = functionType.substitute2(<DartType> [argumentType], <DartType> [parameterType]);

- JUnitTestCase.assertEquals(argumentType, result.returnType);

+ expect(result.returnType, argumentType);

List<DartType> normalParameters = result.normalParameterTypes;

EngineTestCase.assertLength(1, normalParameters);

- JUnitTestCase.assertEquals(argumentType, normalParameters[0]);

+ expect(normalParameters[0], argumentType);

List<DartType> optionalParameters = result.optionalParameterTypes;

EngineTestCase.assertLength(1, optionalParameters);

- JUnitTestCase.assertEquals(argumentType, optionalParameters[0]);

+ expect(optionalParameters[0], argumentType);

Map<String, DartType> namedParameters = result.namedParameterTypes;

EngineTestCase.assertSizeOfMap(1, namedParameters);

- JUnitTestCase.assertEquals(argumentType, namedParameters[namedParameterName]);

+ expect(namedParameters[namedParameterName], argumentType);

}

void test_substitute2_notEqual() {

@@ -1390,16 +1389,16 @@ class FunctionTypeImplTest extends EngineTestCase {

InterfaceTypeImpl argumentType = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("D")));

TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));

FunctionType result = functionType.substitute2(<DartType> [argumentType], <DartType> [parameterType]);

- JUnitTestCase.assertEquals(returnType, result.returnType);

+ expect(result.returnType, returnType);

List<DartType> normalParameters = result.normalParameterTypes;

EngineTestCase.assertLength(1, normalParameters);

- JUnitTestCase.assertEquals(normalParameterType, normalParameters[0]);

+ expect(normalParameters[0], normalParameterType);

List<DartType> optionalParameters = result.optionalParameterTypes;

EngineTestCase.assertLength(1, optionalParameters);

- JUnitTestCase.assertEquals(optionalParameterType, optionalParameters[0]);

+ expect(optionalParameters[0], optionalParameterType);

Map<String, DartType> namedParameters = result.namedParameterTypes;

EngineTestCase.assertSizeOfMap(1, namedParameters);

- JUnitTestCase.assertEquals(namedParameterType, namedParameters[namedParameterName]);

+ expect(namedParameters[namedParameterName], namedParameterType);

}

@@ -1408,26 +1407,26 @@ class HtmlElementImplTest extends EngineTestCase {

AnalysisContextImpl context = createAnalysisContext();

HtmlElementImpl elementA = ElementFactory.htmlUnit(context, "indexA.html");

HtmlElementImpl elementB = ElementFactory.htmlUnit(context, "indexB.html");

- JUnitTestCase.assertFalse(elementA == elementB);

+ expect(elementA == elementB, isFalse);

}

void test_equals_null() {

AnalysisContextImpl context = createAnalysisContext();

HtmlElementImpl element = ElementFactory.htmlUnit(context, "index.html");

- JUnitTestCase.assertFalse(element == null);

+ expect(element == null, isFalse);

}

void test_equals_sameSource() {

AnalysisContextImpl context = createAnalysisContext();

HtmlElementImpl elementA = ElementFactory.htmlUnit(context, "index.html");

HtmlElementImpl elementB = ElementFactory.htmlUnit(context, "index.html");

- JUnitTestCase.assertTrue(elementA == elementB);

+ expect(elementA == elementB, isTrue);

}

void test_equals_self() {

AnalysisContextImpl context = createAnalysisContext();

HtmlElementImpl element = ElementFactory.htmlUnit(context, "index.html");

- JUnitTestCase.assertTrue(element == element);

+ expect(element == element, isTrue);

}

@@ -1465,8 +1464,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

classE.interfaces = <InterfaceType> [classB.type, classD.type];

// assertion: even though the longest path to Object for typeB is 2, and typeE implements typeB,

// the longest path for typeE is 4 since it also implements typeD

- JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));

- JUnitTestCase.assertEquals(4, InterfaceTypeImpl.computeLongestInheritancePathToObject(classE.type));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type), 2);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classE.type), 4);

}

void test_computeLongestInheritancePathToObject_multipleSuperclassPaths() {

@@ -1489,8 +1488,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

classE.interfaces = <InterfaceType> [classD.type];

// assertion: even though the longest path to Object for typeB is 2, and typeE extends typeB,

// the longest path for typeE is 4 since it also implements typeD

- JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));

- JUnitTestCase.assertEquals(4, InterfaceTypeImpl.computeLongestInheritancePathToObject(classE.type));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type), 2);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classE.type), 4);

}

void test_computeLongestInheritancePathToObject_object() {

@@ -1501,14 +1500,14 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType object = classA.supertype;

- JUnitTestCase.assertEquals(0, InterfaceTypeImpl.computeLongestInheritancePathToObject(object));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(object), 0);

}

void test_computeLongestInheritancePathToObject_recursion() {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);

classA.supertype = classB.type;

- JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type), 2);

}

void test_computeLongestInheritancePathToObject_singleInterfacePath() {

@@ -1526,9 +1525,9 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classC = ElementFactory.classElement2("C", []);

classB.interfaces = <InterfaceType> [classA.type];

classC.interfaces = <InterfaceType> [classB.type];

- JUnitTestCase.assertEquals(1, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));

- JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));

- JUnitTestCase.assertEquals(3, InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type), 1);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type), 2);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type), 3);

}

void test_computeLongestInheritancePathToObject_singleSuperclassPath() {

@@ -1544,9 +1543,9 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classA = ElementFactory.classElement2("A", []);

ClassElement classB = ElementFactory.classElement("B", classA.type, []);

ClassElement classC = ElementFactory.classElement("C", classB.type, []);

- JUnitTestCase.assertEquals(1, InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type));

- JUnitTestCase.assertEquals(2, InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type));

- JUnitTestCase.assertEquals(3, InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type));

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classA.type), 1);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classB.type), 2);

+ expect(InterfaceTypeImpl.computeLongestInheritancePathToObject(classC.type), 3);

}

void test_computeSuperinterfaceSet_genericInterfacePath() {

@@ -1573,22 +1572,22 @@ class InterfaceTypeImplTest extends EngineTestCase {

Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(typeA);

EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);

InterfaceType typeObject = ElementFactory.object.type;

- JUnitTestCase.assertTrue(superinterfacesOfA.contains(typeObject));

+ expect(superinterfacesOfA.contains(typeObject), isTrue);

// B<D>

InterfaceTypeImpl typeBD = new InterfaceTypeImpl.con1(classB);

typeBD.typeArguments = <DartType> [classD.type];

Set<InterfaceType> superinterfacesOfBD = InterfaceTypeImpl.computeSuperinterfaceSet(typeBD);

EngineTestCase.assertSizeOfSet(2, superinterfacesOfBD);

- JUnitTestCase.assertTrue(superinterfacesOfBD.contains(typeObject));

- JUnitTestCase.assertTrue(superinterfacesOfBD.contains(typeA));

+ expect(superinterfacesOfBD.contains(typeObject), isTrue);

+ expect(superinterfacesOfBD.contains(typeA), isTrue);

// C<D>

InterfaceTypeImpl typeCD = new InterfaceTypeImpl.con1(classC);

typeCD.typeArguments = <DartType> [classD.type];

Set<InterfaceType> superinterfacesOfCD = InterfaceTypeImpl.computeSuperinterfaceSet(typeCD);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfCD);

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeObject));

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeA));

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeBD));

+ expect(superinterfacesOfCD.contains(typeObject), isTrue);

+ expect(superinterfacesOfCD.contains(typeA), isTrue);

+ expect(superinterfacesOfCD.contains(typeBD), isTrue);

}

void test_computeSuperinterfaceSet_genericSuperclassPath() {

@@ -1614,22 +1613,22 @@ class InterfaceTypeImplTest extends EngineTestCase {

Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(typeA);

EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);

InterfaceType typeObject = ElementFactory.object.type;

- JUnitTestCase.assertTrue(superinterfacesOfA.contains(typeObject));

+ expect(superinterfacesOfA.contains(typeObject), isTrue);

// B<D>

InterfaceTypeImpl typeBD = new InterfaceTypeImpl.con1(classB);

typeBD.typeArguments = <DartType> [classD.type];

Set<InterfaceType> superinterfacesOfBD = InterfaceTypeImpl.computeSuperinterfaceSet(typeBD);

EngineTestCase.assertSizeOfSet(2, superinterfacesOfBD);

- JUnitTestCase.assertTrue(superinterfacesOfBD.contains(typeObject));

- JUnitTestCase.assertTrue(superinterfacesOfBD.contains(typeA));

+ expect(superinterfacesOfBD.contains(typeObject), isTrue);

+ expect(superinterfacesOfBD.contains(typeA), isTrue);

// C<D>

InterfaceTypeImpl typeCD = new InterfaceTypeImpl.con1(classC);

typeCD.typeArguments = <DartType> [classD.type];

Set<InterfaceType> superinterfacesOfCD = InterfaceTypeImpl.computeSuperinterfaceSet(typeCD);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfCD);

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeObject));

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeA));

- JUnitTestCase.assertTrue(superinterfacesOfCD.contains(typeBD));

+ expect(superinterfacesOfCD.contains(typeObject), isTrue);

+ expect(superinterfacesOfCD.contains(typeA), isTrue);

+ expect(superinterfacesOfCD.contains(typeBD), isTrue);

}

void test_computeSuperinterfaceSet_multipleInterfacePaths() {

@@ -1645,17 +1644,17 @@ class InterfaceTypeImplTest extends EngineTestCase {

// D

Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfD);

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(classC.type));

+ expect(superinterfacesOfD.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfD.contains(classA.type), isTrue);

+ expect(superinterfacesOfD.contains(classC.type), isTrue);

// E

Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);

EngineTestCase.assertSizeOfSet(5, superinterfacesOfE);

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classB.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classC.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classD.type));

+ expect(superinterfacesOfE.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfE.contains(classA.type), isTrue);

+ expect(superinterfacesOfE.contains(classB.type), isTrue);

+ expect(superinterfacesOfE.contains(classC.type), isTrue);

+ expect(superinterfacesOfE.contains(classD.type), isTrue);

}

void test_computeSuperinterfaceSet_multipleSuperclassPaths() {

@@ -1668,17 +1667,17 @@ class InterfaceTypeImplTest extends EngineTestCase {

// D

Set<InterfaceType> superinterfacesOfD = InterfaceTypeImpl.computeSuperinterfaceSet(classD.type);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfD);

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfD.contains(classC.type));

+ expect(superinterfacesOfD.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfD.contains(classA.type), isTrue);

+ expect(superinterfacesOfD.contains(classC.type), isTrue);

// E

Set<InterfaceType> superinterfacesOfE = InterfaceTypeImpl.computeSuperinterfaceSet(classE.type);

EngineTestCase.assertSizeOfSet(5, superinterfacesOfE);

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classB.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classC.type));

- JUnitTestCase.assertTrue(superinterfacesOfE.contains(classD.type));

+ expect(superinterfacesOfE.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfE.contains(classA.type), isTrue);

+ expect(superinterfacesOfE.contains(classB.type), isTrue);

+ expect(superinterfacesOfE.contains(classC.type), isTrue);

+ expect(superinterfacesOfE.contains(classD.type), isTrue);

}

void test_computeSuperinterfaceSet_recursion() {

@@ -1698,18 +1697,18 @@ class InterfaceTypeImplTest extends EngineTestCase {

// A

Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);

EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);

- JUnitTestCase.assertTrue(superinterfacesOfA.contains(ElementFactory.object.type));

+ expect(superinterfacesOfA.contains(ElementFactory.object.type), isTrue);

// B

Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);

EngineTestCase.assertSizeOfSet(2, superinterfacesOfB);

- JUnitTestCase.assertTrue(superinterfacesOfB.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfB.contains(classA.type));

+ expect(superinterfacesOfB.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfB.contains(classA.type), isTrue);

// C

Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfC);

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(classB.type));

+ expect(superinterfacesOfC.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfC.contains(classA.type), isTrue);

+ expect(superinterfacesOfC.contains(classB.type), isTrue);

}

void test_computeSuperinterfaceSet_singleSuperclassPath() {

@@ -1726,22 +1725,22 @@ class InterfaceTypeImplTest extends EngineTestCase {

// A

Set<InterfaceType> superinterfacesOfA = InterfaceTypeImpl.computeSuperinterfaceSet(classA.type);

EngineTestCase.assertSizeOfSet(1, superinterfacesOfA);

- JUnitTestCase.assertTrue(superinterfacesOfA.contains(ElementFactory.object.type));

+ expect(superinterfacesOfA.contains(ElementFactory.object.type), isTrue);

// B

Set<InterfaceType> superinterfacesOfB = InterfaceTypeImpl.computeSuperinterfaceSet(classB.type);

EngineTestCase.assertSizeOfSet(2, superinterfacesOfB);

- JUnitTestCase.assertTrue(superinterfacesOfB.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfB.contains(classA.type));

+ expect(superinterfacesOfB.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfB.contains(classA.type), isTrue);

// C

Set<InterfaceType> superinterfacesOfC = InterfaceTypeImpl.computeSuperinterfaceSet(classC.type);

EngineTestCase.assertSizeOfSet(3, superinterfacesOfC);

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(ElementFactory.object.type));

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(classA.type));

- JUnitTestCase.assertTrue(superinterfacesOfC.contains(classB.type));

+ expect(superinterfacesOfC.contains(ElementFactory.object.type), isTrue);

+ expect(superinterfacesOfC.contains(classA.type), isTrue);

+ expect(superinterfacesOfC.contains(classB.type), isTrue);

}

void test_creation() {

- JUnitTestCase.assertNotNull(new InterfaceTypeImpl.con1(ElementFactory.classElement2("A", [])));

+ expect(new InterfaceTypeImpl.con1(ElementFactory.classElement2("A", [])), isNotNull);

}

void test_getAccessors() {

@@ -1750,19 +1749,19 @@ class InterfaceTypeImplTest extends EngineTestCase {

PropertyAccessorElement getterH = ElementFactory.getterElement("h", false, null);

typeElement.accessors = <PropertyAccessorElement> [getterG, getterH];

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(2, type.accessors.length);

+ expect(type.accessors.length, 2);

}

void test_getAccessors_empty() {

ClassElementImpl typeElement = ElementFactory.classElement2("A", []);

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(0, type.accessors.length);

+ expect(type.accessors.length, 0);

}

void test_getElement() {

ClassElementImpl typeElement = ElementFactory.classElement2("A", []);

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(typeElement, type.element);

+ expect(type.element, typeElement);

}

void test_getGetter_implemented() {

@@ -1774,7 +1773,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, null);

classA.accessors = <PropertyAccessorElement> [getterG];

InterfaceType typeA = classA.type;

- JUnitTestCase.assertSame(getterG, typeA.getGetter(getterName));

+ expect(typeA.getGetter(getterName), same(getterG));

}

void test_getGetter_parameterized() {

@@ -1794,9 +1793,9 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);

typeAI.typeArguments = <DartType> [typeI];

PropertyAccessorElement getter = typeAI.getGetter(getterName);

- JUnitTestCase.assertNotNull(getter);

+ expect(getter, isNotNull);

FunctionType getterType = getter.type;

- JUnitTestCase.assertSame(typeI, getterType.returnType);

+ expect(getterType.returnType, same(typeI));

}

void test_getGetter_unimplemented() {

@@ -1805,7 +1804,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertNull(typeA.getGetter("g"));

+ expect(typeA.getGetter("g"), isNull);

}

void test_getInterfaces_nonParameterized() {

@@ -1821,10 +1820,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

List<InterfaceType> interfaces = classC.type.interfaces;

EngineTestCase.assertLength(2, interfaces);

if (identical(interfaces[0], typeA)) {

- JUnitTestCase.assertSame(typeB, interfaces[1]);

+ expect(interfaces[1], same(typeB));

} else {

- JUnitTestCase.assertSame(typeB, interfaces[0]);

- JUnitTestCase.assertSame(typeA, interfaces[1]);

+ expect(interfaces[0], same(typeB));

+ expect(interfaces[1], same(typeA));

}

@@ -1848,8 +1847,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

List<InterfaceType> interfaces = typeBI.interfaces;

EngineTestCase.assertLength(1, interfaces);

InterfaceType result = interfaces[0];

- JUnitTestCase.assertSame(classA, result.element);

- JUnitTestCase.assertSame(typeI, result.typeArguments[0]);

+ expect(result.element, same(classA));

+ expect(result.typeArguments[0], same(typeI));

}

void test_getLeastUpperBound_directInterfaceCase() {

@@ -1866,8 +1865,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeC = classC.type;

classB.interfaces = <InterfaceType> [typeA];

classC.interfaces = <InterfaceType> [typeB];

- JUnitTestCase.assertEquals(typeB, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeB, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeB);

+ expect(typeC.getLeastUpperBound(typeB), typeB);

}

void test_getLeastUpperBound_directSubclassCase() {

@@ -1881,14 +1880,14 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classC = ElementFactory.classElement("C", classB.type, []);

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertEquals(typeB, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeB, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeB);

+ expect(typeC.getLeastUpperBound(typeB), typeB);

}

void test_getLeastUpperBound_functionType() {

DartType interfaceType = ElementFactory.classElement2("A", []).type;

FunctionTypeImpl functionType = new FunctionTypeImpl.con1(new FunctionElementImpl.forNode(AstFactory.identifier3("f")));

- JUnitTestCase.assertNull(interfaceType.getLeastUpperBound(functionType));

+ expect(interfaceType.getLeastUpperBound(functionType), isNull);

}

void test_getLeastUpperBound_mixinCase() {

@@ -1910,13 +1909,13 @@ class InterfaceTypeImplTest extends EngineTestCase {

ElementFactory.classElement2("N", []).type,

ElementFactory.classElement2("O", []).type,

ElementFactory.classElement2("P", []).type];

- JUnitTestCase.assertEquals(typeA, typeD.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeD));

+ expect(typeD.getLeastUpperBound(typeC), typeA);

+ expect(typeC.getLeastUpperBound(typeD), typeA);

}

void test_getLeastUpperBound_null() {

DartType interfaceType = ElementFactory.classElement2("A", []).type;

- JUnitTestCase.assertNull(interfaceType.getLeastUpperBound(null));

+ expect(interfaceType.getLeastUpperBound(null), isNull);

}

void test_getLeastUpperBound_object() {

@@ -1926,17 +1925,17 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

DartType typeObject = typeA.element.supertype;

// assert that object does not have a super type

- JUnitTestCase.assertNull((typeObject.element as ClassElement).supertype);

+ expect((typeObject.element as ClassElement).supertype, isNull);

// assert that both A and B have the same super type of Object

- JUnitTestCase.assertEquals(typeObject, typeB.element.supertype);

+ expect(typeB.element.supertype, typeObject);

// finally, assert that the only least upper bound of A and B is Object

- JUnitTestCase.assertEquals(typeObject, typeA.getLeastUpperBound(typeB));

+ expect(typeA.getLeastUpperBound(typeB), typeObject);

}

void test_getLeastUpperBound_self() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertEquals(typeA, typeA.getLeastUpperBound(typeA));

+ expect(typeA.getLeastUpperBound(typeA), typeA);

}

void test_getLeastUpperBound_sharedSuperclass1() {

@@ -1946,8 +1945,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeA);

+ expect(typeC.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_sharedSuperclass2() {

@@ -1958,8 +1957,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

InterfaceType typeD = classD.type;

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeD));

- JUnitTestCase.assertEquals(typeA, typeD.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeD), typeA);

+ expect(typeD.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_sharedSuperclass3() {

@@ -1970,8 +1969,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

InterfaceType typeD = classD.type;

- JUnitTestCase.assertEquals(typeB, typeC.getLeastUpperBound(typeD));

- JUnitTestCase.assertEquals(typeB, typeD.getLeastUpperBound(typeC));

+ expect(typeC.getLeastUpperBound(typeD), typeB);

+ expect(typeD.getLeastUpperBound(typeC), typeB);

}

void test_getLeastUpperBound_sharedSuperclass4() {

@@ -1987,8 +1986,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeC = classC.type;

classB.interfaces = <InterfaceType> [typeA2];

classC.interfaces = <InterfaceType> [typeA3];

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeA);

+ expect(typeC.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_sharedSuperinterface1() {

@@ -2000,8 +1999,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeC = classC.type;

classB.interfaces = <InterfaceType> [typeA];

classC.interfaces = <InterfaceType> [typeA];

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeA);

+ expect(typeC.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_sharedSuperinterface2() {

@@ -2016,8 +2015,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

classB.interfaces = <InterfaceType> [typeA];

classC.interfaces = <InterfaceType> [typeA];

classD.interfaces = <InterfaceType> [typeC];

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeD));

- JUnitTestCase.assertEquals(typeA, typeD.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeD), typeA);

+ expect(typeD.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_sharedSuperinterface3() {

@@ -2032,8 +2031,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

classB.interfaces = <InterfaceType> [typeA];

classC.interfaces = <InterfaceType> [typeB];

classD.interfaces = <InterfaceType> [typeB];

- JUnitTestCase.assertEquals(typeB, typeC.getLeastUpperBound(typeD));

- JUnitTestCase.assertEquals(typeB, typeD.getLeastUpperBound(typeC));

+ expect(typeC.getLeastUpperBound(typeD), typeB);

+ expect(typeD.getLeastUpperBound(typeC), typeB);

}

void test_getLeastUpperBound_sharedSuperinterface4() {

@@ -2049,14 +2048,14 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeC = classC.type;

classB.interfaces = <InterfaceType> [typeA, typeA2];

classC.interfaces = <InterfaceType> [typeA, typeA3];

- JUnitTestCase.assertEquals(typeA, typeB.getLeastUpperBound(typeC));

- JUnitTestCase.assertEquals(typeA, typeC.getLeastUpperBound(typeB));

+ expect(typeB.getLeastUpperBound(typeC), typeA);

+ expect(typeC.getLeastUpperBound(typeB), typeA);

}

void test_getLeastUpperBound_twoComparables() {

InterfaceType string = _typeProvider.stringType;

InterfaceType num = _typeProvider.numType;

- JUnitTestCase.assertEquals(_typeProvider.objectType, string.getLeastUpperBound(num));

+ expect(string.getLeastUpperBound(num), _typeProvider.objectType);

}

void test_getLeastUpperBound_typeParameters_different() {

@@ -2069,7 +2068,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType doubleType = _typeProvider.doubleType;

InterfaceType listOfIntType = listType.substitute4(<DartType> [intType]);

InterfaceType listOfDoubleType = listType.substitute4(<DartType> [doubleType]);

- JUnitTestCase.assertEquals(_typeProvider.objectType, listOfIntType.getLeastUpperBound(listOfDoubleType));

+ expect(listOfIntType.getLeastUpperBound(listOfDoubleType), _typeProvider.objectType);

}

void test_getLeastUpperBound_typeParameters_same() {

@@ -2080,7 +2079,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType listType = _typeProvider.listType;

InterfaceType intType = _typeProvider.intType;

InterfaceType listOfIntType = listType.substitute4(<DartType> [intType]);

- JUnitTestCase.assertEquals(listOfIntType, listOfIntType.getLeastUpperBound(listOfIntType));

+ expect(listOfIntType.getLeastUpperBound(listOfIntType), listOfIntType);

}

void test_getMethod_implemented() {

@@ -2092,7 +2091,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

MethodElementImpl methodM = ElementFactory.methodElement(methodName, null, []);

classA.methods = <MethodElement> [methodM];

InterfaceType typeA = classA.type;

- JUnitTestCase.assertSame(methodM, typeA.getMethod(methodName));

+ expect(typeA.getMethod(methodName), same(methodM));

}

void test_getMethod_parameterized() {

@@ -2112,12 +2111,12 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);

typeAI.typeArguments = <DartType> [typeI];

MethodElement method = typeAI.getMethod(methodName);

- JUnitTestCase.assertNotNull(method);

+ expect(method, isNotNull);

FunctionType methodType = method.type;

- JUnitTestCase.assertSame(typeI, methodType.returnType);

+ expect(methodType.returnType, same(typeI));

List<DartType> parameterTypes = methodType.normalParameterTypes;

EngineTestCase.assertLength(1, parameterTypes);

- JUnitTestCase.assertSame(typeI, parameterTypes[0]);

+ expect(parameterTypes[0], same(typeI));

}

void test_getMethod_unimplemented() {

@@ -2126,7 +2125,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertNull(typeA.getMethod("m"));

+ expect(typeA.getMethod("m"), isNull);

}

void test_getMethods() {

@@ -2135,13 +2134,13 @@ class InterfaceTypeImplTest extends EngineTestCase {

MethodElementImpl methodTwo = ElementFactory.methodElement("two", null, []);

typeElement.methods = <MethodElement> [methodOne, methodTwo];

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(2, type.methods.length);

+ expect(type.methods.length, 2);

}

void test_getMethods_empty() {

ClassElementImpl typeElement = ElementFactory.classElement2("A", []);

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(typeElement);

- JUnitTestCase.assertEquals(0, type.methods.length);

+ expect(type.methods.length, 0);

}

void test_getMixins_nonParameterized() {

@@ -2157,10 +2156,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

List<InterfaceType> interfaces = classC.type.mixins;

EngineTestCase.assertLength(2, interfaces);

if (identical(interfaces[0], typeA)) {

- JUnitTestCase.assertSame(typeB, interfaces[1]);

+ expect(interfaces[1], same(typeB));

} else {

- JUnitTestCase.assertSame(typeB, interfaces[0]);

- JUnitTestCase.assertSame(typeA, interfaces[1]);

+ expect(interfaces[0], same(typeB));

+ expect(interfaces[1], same(typeA));

}

@@ -2184,8 +2183,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

List<InterfaceType> interfaces = typeBI.mixins;

EngineTestCase.assertLength(1, interfaces);

InterfaceType result = interfaces[0];

- JUnitTestCase.assertSame(classA, result.element);

- JUnitTestCase.assertSame(typeI, result.typeArguments[0]);

+ expect(result.element, same(classA));

+ expect(result.typeArguments[0], same(typeI));

}

void test_getSetter_implemented() {

@@ -2197,7 +2196,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

PropertyAccessorElement setterS = ElementFactory.setterElement(setterName, false, null);

classA.accessors = <PropertyAccessorElement> [setterS];

InterfaceType typeA = classA.type;

- JUnitTestCase.assertSame(setterS, typeA.getSetter(setterName));

+ expect(typeA.getSetter(setterName), same(setterS));

}

void test_getSetter_parameterized() {

@@ -2217,11 +2216,11 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeAI = new InterfaceTypeImpl.con1(classA);

typeAI.typeArguments = <DartType> [typeI];

PropertyAccessorElement setter = typeAI.getSetter(setterName);

- JUnitTestCase.assertNotNull(setter);

+ expect(setter, isNotNull);

FunctionType setterType = setter.type;

List<DartType> parameterTypes = setterType.normalParameterTypes;

EngineTestCase.assertLength(1, parameterTypes);

- JUnitTestCase.assertSame(typeI, parameterTypes[0]);

+ expect(parameterTypes[0], same(typeI));

}

void test_getSetter_unimplemented() {

@@ -2230,7 +2229,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertNull(typeA.getSetter("s"));

+ expect(typeA.getSetter("s"), isNull);

}

void test_getSuperclass_nonParameterized() {

@@ -2241,7 +2240,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

ClassElementImpl classB = ElementFactory.classElement("B", typeA, []);

InterfaceType typeB = classB.type;

- JUnitTestCase.assertSame(typeA, typeB.superclass);

+ expect(typeB.superclass, same(typeA));

}

void test_getSuperclass_parameterized() {

@@ -2262,8 +2261,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);

typeBI.typeArguments = <DartType> [typeI];

InterfaceType superclass = typeBI.superclass;

- JUnitTestCase.assertSame(classA, superclass.element);

- JUnitTestCase.assertSame(typeI, superclass.typeArguments[0]);

+ expect(superclass.element, same(classA));

+ expect(superclass.typeArguments[0], same(typeI));

}

void test_getTypeArguments_empty() {

@@ -2274,7 +2273,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

void test_hashCode() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertFalse(0 == typeA.hashCode);

+ expect(0 == typeA.hashCode, isFalse);

}

void test_isAssignableTo_typeVariables() {

@@ -2293,11 +2292,11 @@ class InterfaceTypeImplTest extends EngineTestCase {

typeAF.typeArguments = <DartType> [classB.typeParameters[0].type];

InterfaceTypeImpl typeAG = new InterfaceTypeImpl.con1(classA);

typeAG.typeArguments = <DartType> [classB.typeParameters[1].type];

- JUnitTestCase.assertFalse(typeAG.isAssignableTo(typeAF));

+ expect(typeAG.isAssignableTo(typeAF), isFalse);

}

void test_isAssignableTo_void() {

- JUnitTestCase.assertFalse(VoidTypeImpl.instance.isAssignableTo(_typeProvider.intType));

+ expect(VoidTypeImpl.instance.isAssignableTo(_typeProvider.intType), isFalse);

}

void test_isDirectSupertypeOf_extends() {

@@ -2305,7 +2304,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classB = ElementFactory.classElement("B", classA.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

- JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));

+ expect(typeA.isDirectSupertypeOf(typeB), isTrue);

}

void test_isDirectSupertypeOf_false() {

@@ -2314,7 +2313,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classC = ElementFactory.classElement("C", classB.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertFalse(typeA.isDirectSupertypeOf(typeC));

+ expect(typeA.isDirectSupertypeOf(typeC), isFalse);

}

void test_isDirectSupertypeOf_implements() {

@@ -2323,7 +2322,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

classB.interfaces = <InterfaceType> [typeA];

- JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));

+ expect(typeA.isDirectSupertypeOf(typeB), isTrue);

}

void test_isDirectSupertypeOf_with() {

@@ -2332,12 +2331,12 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

classB.mixins = <InterfaceType> [typeA];

- JUnitTestCase.assertTrue(typeA.isDirectSupertypeOf(typeB));

+ expect(typeA.isDirectSupertypeOf(typeB), isTrue);

}

void test_isMoreSpecificThan_bottom() {

DartType type = ElementFactory.classElement2("A", []).type;

- JUnitTestCase.assertTrue(BottomTypeImpl.instance.isMoreSpecificThan(type));

+ expect(BottomTypeImpl.instance.isMoreSpecificThan(type), isTrue);

}

void test_isMoreSpecificThan_covariance() {

@@ -2348,8 +2347,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeAJ = new InterfaceTypeImpl.con1(classA);

typeAI.typeArguments = <DartType> [classI.type];

typeAJ.typeArguments = <DartType> [classJ.type];

- JUnitTestCase.assertTrue(typeAJ.isMoreSpecificThan(typeAI));

- JUnitTestCase.assertFalse(typeAI.isMoreSpecificThan(typeAJ));

+ expect(typeAJ.isMoreSpecificThan(typeAI), isTrue);

+ expect(typeAI.isMoreSpecificThan(typeAJ), isFalse);

}

void test_isMoreSpecificThan_directSupertype() {

@@ -2357,14 +2356,14 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classB = ElementFactory.classElement("B", classA.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

- JUnitTestCase.assertTrue(typeB.isMoreSpecificThan(typeA));

+ expect(typeB.isMoreSpecificThan(typeA), isTrue);

// the opposite test tests a different branch in isMoreSpecificThan()

- JUnitTestCase.assertFalse(typeA.isMoreSpecificThan(typeB));

+ expect(typeA.isMoreSpecificThan(typeB), isFalse);

}

void test_isMoreSpecificThan_dynamic() {

InterfaceType type = ElementFactory.classElement2("A", []).type;

- JUnitTestCase.assertTrue(type.isMoreSpecificThan(DynamicTypeImpl.instance));

+ expect(type.isMoreSpecificThan(DynamicTypeImpl.instance), isTrue);

}

void test_isMoreSpecificThan_generic() {

@@ -2373,13 +2372,13 @@ class InterfaceTypeImplTest extends EngineTestCase {

DartType dynamicType = DynamicTypeImpl.instance;

InterfaceType typeAOfDynamic = classA.type.substitute4(<DartType> [dynamicType]);

InterfaceType typeAOfB = classA.type.substitute4(<DartType> [classB.type]);

- JUnitTestCase.assertFalse(typeAOfDynamic.isMoreSpecificThan(typeAOfB));

- JUnitTestCase.assertTrue(typeAOfB.isMoreSpecificThan(typeAOfDynamic));

+ expect(typeAOfDynamic.isMoreSpecificThan(typeAOfB), isFalse);

+ expect(typeAOfB.isMoreSpecificThan(typeAOfDynamic), isTrue);

}

void test_isMoreSpecificThan_self() {

InterfaceType type = ElementFactory.classElement2("A", []).type;

- JUnitTestCase.assertTrue(type.isMoreSpecificThan(type));

+ expect(type.isMoreSpecificThan(type), isTrue);

}

void test_isMoreSpecificThan_transitive_interface() {

@@ -2394,7 +2393,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

classC.interfaces = <InterfaceType> [classB.type];

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));

+ expect(typeC.isMoreSpecificThan(typeA), isTrue);

}

void test_isMoreSpecificThan_transitive_mixin() {

@@ -2409,7 +2408,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

classC.mixins = <InterfaceType> [classB.type];

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));

+ expect(typeC.isMoreSpecificThan(typeA), isTrue);

}

void test_isMoreSpecificThan_transitive_recursive() {

@@ -2424,7 +2423,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

classA.supertype = classB.type;

- JUnitTestCase.assertFalse(typeA.isMoreSpecificThan(typeC));

+ expect(typeA.isMoreSpecificThan(typeC), isFalse);

}

void test_isMoreSpecificThan_transitive_superclass() {

@@ -2438,7 +2437,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classC = ElementFactory.classElement("C", classB.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertTrue(typeC.isMoreSpecificThan(typeA));

+ expect(typeC.isMoreSpecificThan(typeA), isTrue);

}

void test_isMoreSpecificThan_typeParameterType() {

@@ -2449,8 +2448,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

TypeParameterType parameterType = classA.typeParameters[0].type;

DartType objectType = _typeProvider.objectType;

- JUnitTestCase.assertTrue(parameterType.isMoreSpecificThan(objectType));

- JUnitTestCase.assertFalse(parameterType.isMoreSpecificThan(typeA));

+ expect(parameterType.isMoreSpecificThan(objectType), isTrue);

+ expect(parameterType.isMoreSpecificThan(typeA), isFalse);

}

void test_isMoreSpecificThan_typeParameterType_withBound() {

@@ -2466,7 +2465,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

parameterEA.bound = typeA;

parameterEA.type = parameterAEType;

classB.typeParameters = <TypeParameterElementImpl> [parameterEA];

- JUnitTestCase.assertTrue(parameterAEType.isMoreSpecificThan(typeA));

+ expect(parameterAEType.isMoreSpecificThan(typeA), isTrue);

}

void test_isSubtypeOf_directSubtype() {

@@ -2474,16 +2473,16 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classB = ElementFactory.classElement("B", classA.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

- JUnitTestCase.assertTrue(typeB.isSubtypeOf(typeA));

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeB));

+ expect(typeB.isSubtypeOf(typeA), isTrue);

+ expect(typeA.isSubtypeOf(typeB), isFalse);

}

void test_isSubtypeOf_dynamic() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

DartType dynamicType = DynamicTypeImpl.instance;

- JUnitTestCase.assertTrue(dynamicType.isSubtypeOf(typeA));

- JUnitTestCase.assertTrue(typeA.isSubtypeOf(dynamicType));

+ expect(dynamicType.isSubtypeOf(typeA), isTrue);

+ expect(typeA.isSubtypeOf(dynamicType), isTrue);

}

void test_isSubtypeOf_function() {

@@ -2497,7 +2496,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElementImpl classA = ElementFactory.classElement2("A", []);

classA.methods = <MethodElement> [ElementFactory.methodElement("call", VoidTypeImpl.instance, [stringType])];

FunctionType functionType = ElementFactory.functionElement5("f", <ClassElement> [stringType.element]).type;

- JUnitTestCase.assertTrue(classA.type.isSubtypeOf(functionType));

+ expect(classA.type.isSubtypeOf(functionType), isTrue);

}

void test_isSubtypeOf_generic() {

@@ -2506,8 +2505,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

DartType dynamicType = DynamicTypeImpl.instance;

InterfaceType typeAOfDynamic = classA.type.substitute4(<DartType> [dynamicType]);

InterfaceType typeAOfB = classA.type.substitute4(<DartType> [classB.type]);

- JUnitTestCase.assertTrue(typeAOfDynamic.isSubtypeOf(typeAOfB));

- JUnitTestCase.assertTrue(typeAOfB.isSubtypeOf(typeAOfDynamic));

+ expect(typeAOfDynamic.isSubtypeOf(typeAOfB), isTrue);

+ expect(typeAOfB.isSubtypeOf(typeAOfDynamic), isTrue);

}

void test_isSubtypeOf_interface() {

@@ -2519,10 +2518,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

classC.interfaces = <InterfaceType> [typeB];

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeB));

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeObject));

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));

+ expect(typeC.isSubtypeOf(typeB), isTrue);

+ expect(typeC.isSubtypeOf(typeObject), isTrue);

+ expect(typeC.isSubtypeOf(typeA), isTrue);

+ expect(typeA.isSubtypeOf(typeC), isFalse);

}

void test_isSubtypeOf_mixins() {

@@ -2539,24 +2538,24 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

classC.mixins = <InterfaceType> [typeB];

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeB));

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeObject));

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));

+ expect(typeC.isSubtypeOf(typeB), isTrue);

+ expect(typeC.isSubtypeOf(typeObject), isTrue);

+ expect(typeC.isSubtypeOf(typeA), isTrue);

+ expect(typeA.isSubtypeOf(typeC), isFalse);

}

void test_isSubtypeOf_object() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

InterfaceType typeObject = classA.supertype;

- JUnitTestCase.assertTrue(typeA.isSubtypeOf(typeObject));

- JUnitTestCase.assertFalse(typeObject.isSubtypeOf(typeA));

+ expect(typeA.isSubtypeOf(typeObject), isTrue);

+ expect(typeObject.isSubtypeOf(typeA), isFalse);

}

void test_isSubtypeOf_self() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertTrue(typeA.isSubtypeOf(typeA));

+ expect(typeA.isSubtypeOf(typeA), isTrue);

}

void test_isSubtypeOf_transitive_recursive() {

@@ -2571,7 +2570,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

classA.supertype = classB.type;

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));

+ expect(typeA.isSubtypeOf(typeC), isFalse);

}

void test_isSubtypeOf_transitive_superclass() {

@@ -2580,8 +2579,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classC = ElementFactory.classElement("C", classB.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertTrue(typeC.isSubtypeOf(typeA));

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(typeC));

+ expect(typeC.isSubtypeOf(typeA), isTrue);

+ expect(typeA.isSubtypeOf(typeC), isFalse);

}

void test_isSubtypeOf_typeArguments() {

@@ -2599,19 +2598,19 @@ class InterfaceTypeImplTest extends EngineTestCase {

typeAJ.typeArguments = <DartType> [classJ.type];

typeAK.typeArguments = <DartType> [classK.type];

// A<J> <: A since J <: I

- JUnitTestCase.assertTrue(typeAJ.isSubtypeOf(typeAI));

- JUnitTestCase.assertFalse(typeAI.isSubtypeOf(typeAJ));

+ expect(typeAJ.isSubtypeOf(typeAI), isTrue);

+ expect(typeAI.isSubtypeOf(typeAJ), isFalse);

// A <: A since I <: I

- JUnitTestCase.assertTrue(typeAI.isSubtypeOf(typeAI));

+ expect(typeAI.isSubtypeOf(typeAI), isTrue);

// A <: A and A <: A<J>

- JUnitTestCase.assertTrue(typeA_dynamic.isSubtypeOf(typeAI));

- JUnitTestCase.assertTrue(typeA_dynamic.isSubtypeOf(typeAJ));

+ expect(typeA_dynamic.isSubtypeOf(typeAI), isTrue);

+ expect(typeA_dynamic.isSubtypeOf(typeAJ), isTrue);

// A <: A and A<J> <: A

- JUnitTestCase.assertTrue(typeAI.isSubtypeOf(typeA_dynamic));

- JUnitTestCase.assertTrue(typeAJ.isSubtypeOf(typeA_dynamic));

+ expect(typeAI.isSubtypeOf(typeA_dynamic), isTrue);

+ expect(typeAJ.isSubtypeOf(typeA_dynamic), isTrue);

// A !<: A<K> and A<K> !<: A

- JUnitTestCase.assertFalse(typeAI.isSubtypeOf(typeAK));

- JUnitTestCase.assertFalse(typeAK.isSubtypeOf(typeAI));

+ expect(typeAI.isSubtypeOf(typeAK), isFalse);

+ expect(typeAK.isSubtypeOf(typeAI), isFalse);

}

void test_isSubtypeOf_typeParameter() {

@@ -2621,7 +2620,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classA = ElementFactory.classElement2("A", ["E"]);

InterfaceType typeA = classA.type;

TypeParameterType parameterType = classA.typeParameters[0].type;

- JUnitTestCase.assertFalse(typeA.isSubtypeOf(parameterType));

+ expect(typeA.isSubtypeOf(parameterType), isFalse);

}

void test_isSupertypeOf_directSupertype() {

@@ -2629,16 +2628,16 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classB = ElementFactory.classElement("B", classA.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeB = classB.type;

- JUnitTestCase.assertFalse(typeB.isSupertypeOf(typeA));

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeB));

+ expect(typeB.isSupertypeOf(typeA), isFalse);

+ expect(typeA.isSupertypeOf(typeB), isTrue);

}

void test_isSupertypeOf_dynamic() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

DartType dynamicType = DynamicTypeImpl.instance;

- JUnitTestCase.assertTrue(dynamicType.isSupertypeOf(typeA));

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(dynamicType));

+ expect(dynamicType.isSupertypeOf(typeA), isTrue);

+ expect(typeA.isSupertypeOf(dynamicType), isTrue);

}

void test_isSupertypeOf_indirectSupertype() {

@@ -2647,8 +2646,8 @@ class InterfaceTypeImplTest extends EngineTestCase {

ClassElement classC = ElementFactory.classElement("C", classB.type, []);

InterfaceType typeA = classA.type;

InterfaceType typeC = classC.type;

- JUnitTestCase.assertFalse(typeC.isSupertypeOf(typeA));

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeC));

+ expect(typeC.isSupertypeOf(typeA), isFalse);

+ expect(typeA.isSupertypeOf(typeC), isTrue);

}

void test_isSupertypeOf_interface() {

@@ -2660,10 +2659,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

classC.interfaces = <InterfaceType> [typeB];

- JUnitTestCase.assertTrue(typeB.isSupertypeOf(typeC));

- JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeC));

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeC));

- JUnitTestCase.assertFalse(typeC.isSupertypeOf(typeA));

+ expect(typeB.isSupertypeOf(typeC), isTrue);

+ expect(typeObject.isSupertypeOf(typeC), isTrue);

+ expect(typeA.isSupertypeOf(typeC), isTrue);

+ expect(typeC.isSupertypeOf(typeA), isFalse);

}

void test_isSupertypeOf_mixins() {

@@ -2680,24 +2679,24 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType typeB = classB.type;

InterfaceType typeC = classC.type;

classC.mixins = <InterfaceType> [typeB];

- JUnitTestCase.assertTrue(typeB.isSupertypeOf(typeC));

- JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeC));

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeC));

- JUnitTestCase.assertFalse(typeC.isSupertypeOf(typeA));

+ expect(typeB.isSupertypeOf(typeC), isTrue);

+ expect(typeObject.isSupertypeOf(typeC), isTrue);

+ expect(typeA.isSupertypeOf(typeC), isTrue);

+ expect(typeC.isSupertypeOf(typeA), isFalse);

}

void test_isSupertypeOf_object() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

InterfaceType typeObject = classA.supertype;

- JUnitTestCase.assertFalse(typeA.isSupertypeOf(typeObject));

- JUnitTestCase.assertTrue(typeObject.isSupertypeOf(typeA));

+ expect(typeA.isSupertypeOf(typeObject), isFalse);

+ expect(typeObject.isSupertypeOf(typeA), isTrue);

}

void test_isSupertypeOf_self() {

ClassElement classA = ElementFactory.classElement2("A", []);

InterfaceType typeA = classA.type;

- JUnitTestCase.assertTrue(typeA.isSupertypeOf(typeA));

+ expect(typeA.isSupertypeOf(typeA), isTrue);

}

void test_lookUpGetter_implemented() {

@@ -2712,7 +2711,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(getterG, typeA.lookUpGetter(getterName, library));

+ expect(typeA.lookUpGetter(getterName, library), same(getterG));

}

void test_lookUpGetter_inherited() {

@@ -2729,7 +2728,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(getterG, typeB.lookUpGetter(getterName, library));

+ expect(typeB.lookUpGetter(getterName, library), same(getterG));

}

void test_lookUpGetter_recursive() {

@@ -2744,7 +2743,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(typeA.lookUpGetter("g", library));

+ expect(typeA.lookUpGetter("g", library), isNull);

}

void test_lookUpGetter_unimplemented() {

@@ -2756,7 +2755,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(typeA.lookUpGetter("g", library));

+ expect(typeA.lookUpGetter("g", library), isNull);

}

void test_lookUpMethod_implemented() {

@@ -2771,7 +2770,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(methodM, typeA.lookUpMethod(methodName, library));

+ expect(typeA.lookUpMethod(methodName, library), same(methodM));

}

void test_lookUpMethod_inherited() {

@@ -2788,7 +2787,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(methodM, typeB.lookUpMethod(methodName, library));

+ expect(typeB.lookUpMethod(methodName, library), same(methodM));

}

void test_lookUpMethod_parameterized() {

@@ -2817,12 +2816,12 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl typeBI = new InterfaceTypeImpl.con1(classB);

typeBI.typeArguments = <DartType> [typeI];

MethodElement method = typeBI.lookUpMethod(methodName, library);

- JUnitTestCase.assertNotNull(method);

+ expect(method, isNotNull);

FunctionType methodType = method.type;

- JUnitTestCase.assertSame(typeI, methodType.returnType);

+ expect(methodType.returnType, same(typeI));

List<DartType> parameterTypes = methodType.normalParameterTypes;

EngineTestCase.assertLength(1, parameterTypes);

- JUnitTestCase.assertSame(typeI, parameterTypes[0]);

+ expect(parameterTypes[0], same(typeI));

}

void test_lookUpMethod_recursive() {

@@ -2837,7 +2836,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(typeA.lookUpMethod("m", library));

+ expect(typeA.lookUpMethod("m", library), isNull);

}

void test_lookUpMethod_unimplemented() {

@@ -2849,7 +2848,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(typeA.lookUpMethod("m", library));

+ expect(typeA.lookUpMethod("m", library), isNull);

}

void test_lookUpSetter_implemented() {

@@ -2864,7 +2863,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertSame(setterS, typeA.lookUpSetter(setterName, library));

+ expect(typeA.lookUpSetter(setterName, library), same(setterS));

}

void test_lookUpSetter_inherited() {

@@ -2881,7 +2880,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertSame(setterS, typeB.lookUpSetter(setterName, library));

+ expect(typeB.lookUpSetter(setterName, library), same(setterS));

}

void test_lookUpSetter_recursive() {

@@ -2896,7 +2895,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA, classB];

- JUnitTestCase.assertNull(typeA.lookUpSetter("s", library));

+ expect(typeA.lookUpSetter("s", library), isNull);

}

void test_lookUpSetter_unimplemented() {

@@ -2908,7 +2907,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");

CompilationUnitElement unit = library.definingCompilationUnit;

(unit as CompilationUnitElementImpl).types = <ClassElement> [classA];

- JUnitTestCase.assertNull(typeA.lookUpSetter("s", library));

+ expect(typeA.lookUpSetter("s", library), isNull);

}

void test_setTypeArguments() {

@@ -2917,7 +2916,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

ElementFactory.classElement2("B", []).type,

ElementFactory.classElement2("C", []).type];

type.typeArguments = typeArguments;

- JUnitTestCase.assertEquals(typeArguments, type.typeArguments);

+ expect(type.typeArguments, typeArguments);

}

void test_substitute_equal() {

@@ -2927,10 +2926,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

List<DartType> args = [argumentType];

List<DartType> params = [classAE.typeParameters[0].type];

InterfaceType typeAESubbed = typeAE.substitute2(args, params);

- JUnitTestCase.assertEquals(classAE, typeAESubbed.element);

+ expect(typeAESubbed.element, classAE);

List<DartType> resultArguments = typeAESubbed.typeArguments;

EngineTestCase.assertLength(1, resultArguments);

- JUnitTestCase.assertEquals(argumentType, resultArguments[0]);

+ expect(resultArguments[0], argumentType);

}

void test_substitute_exception() {

@@ -2939,7 +2938,7 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceTypeImpl type = new InterfaceTypeImpl.con1(classA);

InterfaceType argumentType = ElementFactory.classElement2("B", []).type;

type.substitute2(<DartType> [argumentType], <DartType> []);

- JUnitTestCase.fail("Expected to encounter exception, argument and parameter type array lengths not equal.");

+ fail("Expected to encounter exception, argument and parameter type array lengths not equal.");

} catch (e) {

// Expected result

}

@@ -2955,10 +2954,10 @@ class InterfaceTypeImplTest extends EngineTestCase {

InterfaceType argumentType = ElementFactory.classElement2("B", []).type;

TypeParameterTypeImpl parameterType = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));

InterfaceType result = type.substitute2(<DartType> [argumentType], <DartType> [parameterType]);

- JUnitTestCase.assertEquals(classA, result.element);

+ expect(result.element, classA);

List<DartType> resultArguments = result.typeArguments;

EngineTestCase.assertLength(1, resultArguments);

- JUnitTestCase.assertEquals(parameter, resultArguments[0]);

+ expect(resultArguments[0], parameter);

}

@@ -2971,7 +2970,7 @@ class InterfaceTypeImpl_FunctionTypeImplTest_test_isSubtypeOf_baseCase_classFunc

class LibraryElementImplTest extends EngineTestCase {

void test_creation() {

- JUnitTestCase.assertNotNull(new LibraryElementImpl.forNode(createAnalysisContext(), AstFactory.libraryIdentifier2(["l"])));

+ expect(new LibraryElementImpl.forNode(createAnalysisContext(), AstFactory.libraryIdentifier2(["l"])), isNotNull);

}

void test_getImportedLibraries() {

@@ -3009,10 +3008,10 @@ class LibraryElementImplTest extends EngineTestCase {

List<PrefixElement> prefixes = library.prefixes;

EngineTestCase.assertLength(2, prefixes);

if (identical(prefixA, prefixes[0])) {

- JUnitTestCase.assertSame(prefixB, prefixes[1]);

+ expect(prefixes[1], same(prefixB));

} else {

- JUnitTestCase.assertSame(prefixB, prefixes[0]);

- JUnitTestCase.assertSame(prefixA, prefixes[1]);

+ expect(prefixes[0], same(prefixB));

+ expect(prefixes[1], same(prefixA));

}

@@ -3091,9 +3090,9 @@ class LibraryElementImplTest extends EngineTestCase {

LibraryElement library = ElementFactory.library(context, "foo");

context.setContents(library.definingCompilationUnit.source, "sdfsdff");

// Assert that we are not up to date if the target has an old time stamp.

- JUnitTestCase.assertFalse(library.isUpToDate(0));

+ expect(library.isUpToDate(0), isFalse);

// Assert that we are up to date with a target modification time in the future.

- JUnitTestCase.assertTrue(library.isUpToDate(JavaSystem.currentTimeMillis() + 1000));

+ expect(library.isUpToDate(JavaSystem.currentTimeMillis() + 1000), isTrue);

}

void test_setImports() {

@@ -3106,7 +3105,7 @@ class LibraryElementImplTest extends EngineTestCase {

List<ImportElement> actualImports = library.imports;

EngineTestCase.assertLength(expectedImports.length, actualImports);

for (int i = 0; i < actualImports.length; i++) {

- JUnitTestCase.assertSame(expectedImports[i], actualImports[i]);

+ expect(actualImports[i], same(expectedImports[i]));

}

@@ -3139,33 +3138,33 @@ class MultiplyDefinedElementImplTest extends EngineTestCase {

void test_fromElements_nonConflicting() {

Element element = ElementFactory.localVariableElement2("xx");

- JUnitTestCase.assertSame(element, MultiplyDefinedElementImpl.fromElements(null, element, element));

+ expect(MultiplyDefinedElementImpl.fromElements(null, element, element), same(element));

}

class TypeParameterTypeImplTest extends EngineTestCase {

void test_creation() {

- JUnitTestCase.assertNotNull(new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))));

+ expect(new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))), isNotNull);

}

void test_getElement() {

TypeParameterElementImpl element = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));

TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);

- JUnitTestCase.assertEquals(element, type.element);

+ expect(type.element, element);

}

void test_isMoreSpecificThan_typeArguments_dynamic() {

TypeParameterElementImpl element = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));

TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);

// E << dynamic

- JUnitTestCase.assertTrue(type.isMoreSpecificThan(DynamicTypeImpl.instance));

+ expect(type.isMoreSpecificThan(DynamicTypeImpl.instance), isTrue);

}

void test_isMoreSpecificThan_typeArguments_object() {

TypeParameterElementImpl element = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));

TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);

// E << Object

- JUnitTestCase.assertTrue(type.isMoreSpecificThan(ElementFactory.object.type));

+ expect(type.isMoreSpecificThan(ElementFactory.object.type), isTrue);

}

void test_isMoreSpecificThan_typeArguments_resursive() {

@@ -3178,14 +3177,14 @@ class TypeParameterTypeImplTest extends EngineTestCase {

typeParameterU.bound = typeParameterTypeU;

// <T extends U> and

// T << S

- JUnitTestCase.assertFalse(typeParameterTypeT.isMoreSpecificThan(classS.type));

+ expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isFalse);

}

void test_isMoreSpecificThan_typeArguments_self() {

TypeParameterElementImpl element = new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));

TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);

// E << E

- JUnitTestCase.assertTrue(type.isMoreSpecificThan(type));

+ expect(type.isMoreSpecificThan(type), isTrue);

}

void test_isMoreSpecificThan_typeArguments_transitivity_interfaceTypes() {

@@ -3201,7 +3200,7 @@ class TypeParameterTypeImplTest extends EngineTestCase {

TypeParameterTypeImpl typeParameterTypeT = new TypeParameterTypeImpl(typeParameterT);

// <T extends B>

// T << A

- JUnitTestCase.assertTrue(typeParameterTypeT.isMoreSpecificThan(typeA));

+ expect(typeParameterTypeT.isMoreSpecificThan(typeA), isTrue);

}

void test_isMoreSpecificThan_typeArguments_transitivity_typeParameters() {

@@ -3214,7 +3213,7 @@ class TypeParameterTypeImplTest extends EngineTestCase {

TypeParameterTypeImpl typeParameterTypeT = new TypeParameterTypeImpl(typeParameterT);

// <T extends U> and

// T << S

- JUnitTestCase.assertTrue(typeParameterTypeT.isMoreSpecificThan(classS.type));

+ expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isTrue);

}

void test_isMoreSpecificThan_typeArguments_upperBound() {

@@ -3224,7 +3223,7 @@ class TypeParameterTypeImplTest extends EngineTestCase {

TypeParameterTypeImpl typeParameterTypeT = new TypeParameterTypeImpl(typeParameterT);

// <T extends S>

// T << S

- JUnitTestCase.assertTrue(typeParameterTypeT.isMoreSpecificThan(classS.type));

+ expect(typeParameterTypeT.isMoreSpecificThan(classS.type), isTrue);

}

void test_substitute_equal() {

@@ -3232,14 +3231,14 @@ class TypeParameterTypeImplTest extends EngineTestCase {

TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);

InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("A")));

TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(element);

- JUnitTestCase.assertSame(argument, type.substitute2(<DartType> [argument], <DartType> [parameter]));

+ expect(type.substitute2(<DartType> [argument], <DartType> [parameter]), same(argument));

}

void test_substitute_notEqual() {

TypeParameterTypeImpl type = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("E")));

InterfaceTypeImpl argument = new InterfaceTypeImpl.con1(new ClassElementImpl.forNode(AstFactory.identifier3("A")));

TypeParameterTypeImpl parameter = new TypeParameterTypeImpl(new TypeParameterElementImpl.forNode(AstFactory.identifier3("F")));

- JUnitTestCase.assertSame(type, type.substitute2(<DartType> [argument], <DartType> [parameter]));

+ expect(type.substitute2(<DartType> [argument], <DartType> [parameter]), same(type));

}

@@ -3268,104 +3267,104 @@ class UnionTypeImplTest extends EngineTestCase {

} on IllegalArgumentException catch (e) {

return;

}

- JUnitTestCase.fail("Expected illegal argument exception.");

+ fail("Expected illegal argument exception.");

}

void test_equality_beingASubtypeOfAnElementIsNotSufficient() {

// Non-equal if some elements are different

- JUnitTestCase.assertFalse(_uAB == _uA);

+ expect(_uAB == _uA, isFalse);

}

void test_equality_insertionOrderDoesntMatter() {

// Insertion order doesn't matter, only sets of elements

- JUnitTestCase.assertTrue(_uAB == _uBA);

- JUnitTestCase.assertTrue(_uBA == _uAB);

+ expect(_uAB == _uBA, isTrue);

+ expect(_uBA == _uAB, isTrue);

}

void test_equality_reflexivity() {

for (DartType u in _us) {

- JUnitTestCase.assertTrue(u == u);

+ expect(u == u, isTrue);

}

void test_equality_singletonsCollapse() {

- JUnitTestCase.assertTrue(_typeA == _uA);

- JUnitTestCase.assertTrue(_uA == _typeA);

+ expect(_typeA == _uA, isTrue);

+ expect(_uA == _typeA, isTrue);

}

void test_isMoreSpecificThan_allElementsOnLHSAreSubtypesOfSomeElementOnRHS() {

// Unions are subtypes when all elements are subtypes

- JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_uA));

- JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_typeA));

+ expect(_uAB.isMoreSpecificThan(_uA), isTrue);

+ expect(_uAB.isMoreSpecificThan(_typeA), isTrue);

}

void test_isMoreSpecificThan_element() {

// Elements of union are sub types

- JUnitTestCase.assertTrue(_typeA.isMoreSpecificThan(_uAB));

- JUnitTestCase.assertTrue(_typeB.isMoreSpecificThan(_uAB));

+ expect(_typeA.isMoreSpecificThan(_uAB), isTrue);

+ expect(_typeB.isMoreSpecificThan(_uAB), isTrue);

}

void test_isMoreSpecificThan_notSubtypeOfAnyElement() {

// Types that are not subtypes of elements are not subtypes

- JUnitTestCase.assertFalse(_typeA.isMoreSpecificThan(_uB));

+ expect(_typeA.isMoreSpecificThan(_uB), isFalse);

}

void test_isMoreSpecificThan_reflexivity() {

for (DartType u in _us) {

- JUnitTestCase.assertTrue(u.isMoreSpecificThan(u));

+ expect(u.isMoreSpecificThan(u), isTrue);

}

void test_isMoreSpecificThan_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS() {

// Unions are subtypes when some element is a subtype

- JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_uB));

- JUnitTestCase.assertTrue(_uAB.isMoreSpecificThan(_typeB));

+ expect(_uAB.isMoreSpecificThan(_uB), isTrue);

+ expect(_uAB.isMoreSpecificThan(_typeB), isTrue);

}

void test_isMoreSpecificThan_subtypeOfSomeElement() {

// Subtypes of elements are sub types

- JUnitTestCase.assertTrue(_typeB.isMoreSpecificThan(_uA));

+ expect(_typeB.isMoreSpecificThan(_uA), isTrue);

}

void test_isSubtypeOf_allElementsOnLHSAreSubtypesOfSomeElementOnRHS() {

// Unions are subtypes when all elements are subtypes

- JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_uA));

- JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_typeA));

+ expect(_uAB.isSubtypeOf(_uA), isTrue);

+ expect(_uAB.isSubtypeOf(_typeA), isTrue);

}

void test_isSubtypeOf_element() {

// Elements of union are sub types

- JUnitTestCase.assertTrue(_typeA.isSubtypeOf(_uAB));

- JUnitTestCase.assertTrue(_typeB.isSubtypeOf(_uAB));

+ expect(_typeA.isSubtypeOf(_uAB), isTrue);

+ expect(_typeB.isSubtypeOf(_uAB), isTrue);

}

void test_isSubtypeOf_notSubtypeOfAnyElement() {

// Types that are not subtypes of elements are not subtypes

- JUnitTestCase.assertFalse(_typeA.isSubtypeOf(_uB));

+ expect(_typeA.isSubtypeOf(_uB), isFalse);

}

void test_isSubtypeOf_reflexivity() {

for (DartType u in _us) {

- JUnitTestCase.assertTrue(u.isSubtypeOf(u));

+ expect(u.isSubtypeOf(u), isTrue);

}

void test_isSubtypeOf_someElementOnLHSIsNotASubtypeOfAnyElementOnRHS() {

// Unions are subtypes when some element is a subtype

- JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_uB));

- JUnitTestCase.assertTrue(_uAB.isSubtypeOf(_typeB));

+ expect(_uAB.isSubtypeOf(_uB), isTrue);

+ expect(_uAB.isSubtypeOf(_typeB), isTrue);

}

void test_isSubtypeOf_subtypeOfSomeElement() {

// Subtypes of elements are sub types

- JUnitTestCase.assertTrue(_typeB.isSubtypeOf(_uA));

+ expect(_typeB.isSubtypeOf(_uA), isTrue);

}

void test_nestedUnionsCollapse() {

UnionType u = UnionTypeImpl.union([_uAB, _typeA]) as UnionType;

for (DartType t in u.elements) {

if (t is UnionType) {

- JUnitTestCase.fail("Expected only non-union types but found $t!");

+ fail("Expected only non-union types but found $t!");

}

@@ -3373,9 +3372,9 @@ class UnionTypeImplTest extends EngineTestCase {

void test_noLossage() {

UnionType u = UnionTypeImpl.union([_typeA, _typeB, _typeB, _typeA, _typeB, _typeB]) as UnionType;

Set<DartType> elements = u.elements;

- JUnitTestCase.assertTrue(elements.contains(_typeA));

- JUnitTestCase.assertTrue(elements.contains(_typeB));

- JUnitTestCase.assertTrue(elements.length == 2);

+ expect(elements.contains(_typeA), isTrue);

+ expect(elements.contains(_typeB), isTrue);

+ expect(elements.length == 2, isTrue);

}

void test_substitute() {

@@ -3385,19 +3384,19 @@ class UnionTypeImplTest extends EngineTestCase {

List<DartType> args = [_typeB];

List<DartType> params = [classAE.typeParameters[0].type];

DartType typeAESubbed = typeAE.substitute2(args, params);

- JUnitTestCase.assertFalse(typeAE == typeAESubbed);

- JUnitTestCase.assertEquals(UnionTypeImpl.union([_typeA, typeAE]).substitute2(args, params), UnionTypeImpl.union([_typeA, typeAESubbed]));

+ expect(typeAE == typeAESubbed, isFalse);

+ expect(UnionTypeImpl.union([_typeA, typeAESubbed]), UnionTypeImpl.union([_typeA, typeAE]).substitute2(args, params));

}

void test_toString_pair() {

String s = _uAB.toString();

- JUnitTestCase.assertTrue(s == "{A,B}" || s == "{B,A}");

- JUnitTestCase.assertEquals(s, _uAB.displayName);

+ expect(s == "{A,B}" || s == "{B,A}", isTrue);

+ expect(_uAB.displayName, s);

}

void test_toString_singleton() {

// Singleton unions collapse to the the single type.

- JUnitTestCase.assertEquals("A", _uA.toString());

+ expect(_uA.toString(), "A");

}

void test_unionTypeIsLessSpecificThan_function() {

@@ -3405,8 +3404,8 @@ class UnionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

DartType uAT = UnionTypeImpl.union([_uA, t]);

- JUnitTestCase.assertTrue(t.isMoreSpecificThan(uAT));

- JUnitTestCase.assertFalse(t.isMoreSpecificThan(_uAB));

+ expect(t.isMoreSpecificThan(uAT), isTrue);

+ expect(t.isMoreSpecificThan(_uAB), isFalse);

}

void test_unionTypeIsSuperTypeOf_function() {

@@ -3414,8 +3413,8 @@ class UnionTypeImplTest extends EngineTestCase {

ClassElement a = ElementFactory.classElement2("A", []);

FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;

DartType uAT = UnionTypeImpl.union([_uA, t]);

- JUnitTestCase.assertTrue(t.isSubtypeOf(uAT));

- JUnitTestCase.assertFalse(t.isSubtypeOf(_uAB));

+ expect(t.isSubtypeOf(uAT), isTrue);

+ expect(t.isSubtypeOf(_uAB), isFalse);

}

@override

@@ -3441,37 +3440,37 @@ class VoidTypeImplTest extends EngineTestCase {

void test_isMoreSpecificThan_void_A() {

ClassElement classA = ElementFactory.classElement2("A", []);

- JUnitTestCase.assertFalse(_voidType.isMoreSpecificThan(classA.type));

+ expect(_voidType.isMoreSpecificThan(classA.type), isFalse);

}

void test_isMoreSpecificThan_void_dynamic() {

- JUnitTestCase.assertTrue(_voidType.isMoreSpecificThan(DynamicTypeImpl.instance));

+ expect(_voidType.isMoreSpecificThan(DynamicTypeImpl.instance), isTrue);

}

void test_isMoreSpecificThan_void_void() {

- JUnitTestCase.assertTrue(_voidType.isMoreSpecificThan(_voidType));

+ expect(_voidType.isMoreSpecificThan(_voidType), isTrue);

}

void test_isSubtypeOf_void_A() {

ClassElement classA = ElementFactory.classElement2("A", []);

- JUnitTestCase.assertFalse(_voidType.isSubtypeOf(classA.type));

+ expect(_voidType.isSubtypeOf(classA.type), isFalse);

}

void test_isSubtypeOf_void_dynamic() {

- JUnitTestCase.assertTrue(_voidType.isSubtypeOf(DynamicTypeImpl.instance));

+ expect(_voidType.isSubtypeOf(DynamicTypeImpl.instance), isTrue);

}

void test_isSubtypeOf_void_void() {

- JUnitTestCase.assertTrue(_voidType.isSubtypeOf(_voidType));

+ expect(_voidType.isSubtypeOf(_voidType), isTrue);

}

void test_isVoid() {

- JUnitTestCase.assertTrue(_voidType.isVoid);

+ expect(_voidType.isVoid, isTrue);

}

main() {

- _ut.groupSep = ' | ';

+ groupSep = ' | ';

runReflectiveTests(AngularPropertyKindTest);

runReflectiveTests(ElementKindTest);

runReflectiveTests(FunctionTypeImplTest);

« no previous file with comments | « pkg/analyzer/test/generated/ast_test.dart ('k') | pkg/analyzer/test/generated/engine_test.dart » ('j') | pkg/analyzer/test/generated/test_support.dart » ('J')