anchor.diff:    const SetEquality<String>();
   }
   ''');
  -  }
  -
  -  test_constructorInvalid() async {
  -    // Regression test for https://github.com/dart-lang/sdk/issues/26695
  -    await assertErrorsInCode('''
  -class A {
  -  B({this.test: 1.0 }) {}
  -  final double test = 0.0;
  -}
  -''', [
  -      error(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, 15, 9),
  -    ]);
     }
   
     test_constructors() async {
  
positive.code:       error(CompileTimeErrorCode.UNDEFINED_METHOD, 755, 3),
        error(CompileTimeErrorCode.UNDEFINED_METHOD, 772, 3),
        error(CompileTimeErrorCode.UNDEFINED_GETTER, 789, 1),
      ]);
    }
  
    test_factoryConstructorDowncast() async {
      await assertErrorsInCode(r'''
  class Animal {
    Animal();
    factory Animal.cat() => new Cat();
  }
  
  class Cat extends Animal {}
  
  void main() {
    Cat c = new Animal.cat();
    c = new Animal();
  }''', [
        error(HintCode.UNUSED_LOCAL_VARIABLE, 116, 1),
        error(CompileTimeErrorCode.INVALID_CAST_NEW_EXPR, 144, 12),
      ]);
    }
  
    test_fieldFieldOverride() async {
      await assertErrorsInCode('''
  class A {}
  class B extends A {}
  class C extends B {}
  
  class Base {
    B f1;
    B f2;
    B f3;
    B f4;
  }
  
  class Child extends Base {
    A f1; // invalid for getter
    C f2; // invalid for setter
    var f3;
    dynamic f4;
  }
  
  class Child2 implements Base {
    A f1; // invalid for getter
    C f2; // invalid for setter
    var f3;
    dynamic f4;
  }
  ''', [
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 133, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 163, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 209, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 251, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 281, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 327, 2),
      ]);
    }
  
    test_fieldGetterOverride() async {
      await assertErrorsInCode('''
  class A {}
  class B extends A {}
  class C extends B {}
  
  abstract class Base {
    B f1;
    B f2;
    B f3;
    B f4;
  }
  
  class Child extends Base {
    A get f1 => null;
    C get f2 => null;
    get f3 => null;
    dynamic get f4 => null;
  }
  
  class Child2 implements Base {
    A get f1 => null;
    C get f2 => null;
    get f3 => null;
    dynamic get f4 => null;
  }
  ''', [
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 146, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 210, 2),
        error(
            CompileTimeErrorCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR,
            231,
            6),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 264, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 328, 2),
      ]);
    }
  
    test_fieldOverride() async {
      await assertErrorsInCode('''
  typedef void ToVoid<T>(T x);
  class F {
    final ToVoid<dynamic> f = null;
    final ToVoid<int> g = null;
  }
  
  class G extends F {
    final ToVoid<int> f = null;
    final ToVoid<dynamic> g = null;
  }
  
  class H implements F {
    final ToVoid<int> f = null;
    final ToVoid<dynamic> g = null;
  }
   ''', [
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 146, 1),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 236, 1),
      ]);
    }
  
    test_fieldSetterOverride() async {
      await assertErrorsInCode('''
  class A {}
  class B extends A {}
  class C extends B {}
  
  class Base {
    B f1;
    B f2;
    B f3;
    B f4;
    B f5;
  }
  
  class Child extends Base {
    B get f1 => null;
    B get f2 => null;
    B get f3 => null;
    B get f4 => null;
    B get f5 => null;
  
    void set f1(A value) {}
    void set f2(C value) {}
    void set f3(value) {}
    void set f4(dynamic value) {}
    set f5(B value) {}
  }
  
  class Child2 implements Base {
    B get f1 => null;
    B get f2 => null;
    B get f3 => null;
    B get f4 => null;
    B get f5 => null;
  
    void set f1(A value) {}
    void set f2(C value) {}
    void set f3(value) {}
    void set f4(dynamic value) {}
    set f5(B value) {}
  }
  ''', [
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 275, 2),
        error(CompileTimeErrorCode.INVALID_OVERRIDE, 539, 2),
      ]);
    }
  
  
negative.code:       error(CompileTimeErrorCode.VARIABLE_TYPE_MISMATCH, 149, 1),
        error(HintCode.UNUSED_LOCAL_VARIABLE, 283, 1),
        error(CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT, 295, 1),
      ]);
    }
  
  