anchor.diff:        error(CompileTimeErrorCode.VARIABLE_TYPE_MISMATCH, 149, 1),
         error(HintCode.UNUSED_LOCAL_VARIABLE, 283, 1),
         error(CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT, 295, 1),
  -    ]);
  -  }
  -
  -  test_classOverrideOfGrandInterface_interfaceOfAbstractSuperclass() async {
  -    await assertErrorsInCode('''
  -class A {}
  -class B {}
  -
  -abstract class I1 {
  -  m(A a);
  -}
  -abstract class Base implements I1 {}
  -
  -class T1 extends Base {
  -  m(B a) {}
  -}
  -''', [
  -      error(CompileTimeErrorCode.INVALID_OVERRIDE, 119, 1),
  -    ]);
  -  }
  -
  -  test_classOverrideOfGrandInterface_interfaceOfConcreteSuperclass() async {
  -    await assertErrorsInCode('''
  -class A {}
  -class B {}
  -
  -abstract class I1 {
  -  m(A a);
  -}
  -
  -class Base implements I1 {}
  -
  -class T1 extends Base {
  -  m(B a) {}
  -}
  -''', [
  -      error(
  -          CompileTimeErrorCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
  -          62,
  -          4),
  -      error(CompileTimeErrorCode.INVALID_OVERRIDE, 111, 1),
  -    ]);
  -  }
  -
  -  test_classOverrideOfGrandInterface_interfaceOfInterfaceOfChild() async {
  -    await assertErrorsInCode('''
  -class A {}
  -class B {}
  -
  -abstract class I1 {
  -  m(A a);
  -}
  -abstract class I2 implements I1 {}
  -
  -class T1 implements I2 {
  -  m(B a) {}
  -}
  -''', [
  -      error(CompileTimeErrorCode.INVALID_OVERRIDE, 118, 1),
  -    ]);
  -  }
  -
  -  test_classOverrideOfGrandInterface_mixinOfInterfaceOfChild() async {
  -    await assertErrorsInCode('''
  -class A {}
  -class B {}
  -
  -abstract class M1 {
  -  m(A a);
  -}
  -abstract class I2 extends Object with M1 {}
  -
  -class T1 implements I2 {
  -  m(B a) {}
  -}
  -''', [
  -      error(CompileTimeErrorCode.INVALID_OVERRIDE, 127, 1),
  -    ]);
  -  }
  -
  -  test_classOverrideOfGrandInterface_superclassOfInterfaceOfChild() async {
  -    await assertErrorsInCode('''
  -class A {}
  -class B {}
  -
  -abstract class I1 {
  -  m(A a);
  -}
  -abstract class I2 extends I1 {}
  -
  -class T1 implements I2 {
  -  m(B a) {}
  -}
  -''', [
  -      error(CompileTimeErrorCode.INVALID_OVERRIDE, 115, 1),
       ]);
     }
   
  
positive.code:     ]);
    }
  
    test_covariantOverride() async {
      await assertErrorsInCode(r'''
  class C {
    num f(num x) => x;
  }
  class D extends C {
    int f(covariant int x) => x;
  }
  class E extends D {
    int f(Object x) => x;
  }
  class F extends E {
    int f(covariant int x) => x;
  }
  class G extends E implements D {}
  
  class D_error extends C {
    int f(int x) => x;
  }
  class E_error extends D {
    int f(covariant double x) => 0;
  }
  class F_error extends E {
    int f(covariant double x) => 0;
  }
  class G_error extends E implements D {
    int f(covariant double x) => 0;
  }
  ''', [
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 252, 1),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 301, 1),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 363, 1),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 438, 1),
      ]);
    }
  
    @failingTest
    test_covariantOverride_fields() async {
      await assertNoErrorsInCode(r'''
  class A {
    get foo => '';
    set foo(_) {}
  }
  
  class B extends A {
    covariant num foo;
  }
  class C extends A {
    covariant num foo;
  }
  class D extends C {
    int foo;
  }
  class E extends D {
    num foo;
  }
  ''');
    }
  
    test_covariantOverride_leastUpperBound() async {
      await assertNoErrorsInCode(r'''
  abstract class Top {}
  
negative.code:   const SetEquality<String>();
  }
  ''');
    }
  
    test_constructors() async {
  