anchor.diff:  
   main() {
     defineReflectiveSuite(() {
  +    defineReflectiveTests(AssignabilityTest);
       defineReflectiveTests(ConstraintMatchingTest);
  -    defineReflectiveTests(StrongAssignabilityTest);
  -    defineReflectiveTests(StrongSubtypingTest);
  +    defineReflectiveTests(GenericFunctionInferenceTest);
  +    defineReflectiveTests(GreatestLowerBoundTest);
  +    defineReflectiveTests(LeastUpperBoundFunctionsTest);
  +    defineReflectiveTests(LeastUpperBoundTest);
       defineReflectiveTests(NonNullableSubtypingTest);
  -    defineReflectiveTests(StrongGenericFunctionInferenceTest);
  -    defineReflectiveTests(StrongLeastUpperBoundTest);
  -    defineReflectiveTests(StrongGreatestLowerBoundTest);
  +    defineReflectiveTests(SubtypingTest);
       defineReflectiveTests(TypeSystemTest);
     });
   }
  
positive.code:   }
  }
  
  /**
   * Tests LUB in strong mode.
   *
   * Tests defined in this class are ones whose behavior is spec mode-specific.
   * In particular, function parameters are compared using LUB in spec mode, but
   * GLB in strong mode.
   */
  @reflectiveTest
  class StrongLeastUpperBoundTest extends LeastUpperBoundTestBase {
    void setUp() {
      super.setUp();
      typeSystem = new Dart2TypeSystem(typeProvider);
    }
  
    void test_functionsFuzzyArrows() {
  
negative.code:     _checkLeastUpperBound(s, u, AType.instantiate([objectType]));
    }
  
    void test_typeParam_function_bounded() {
      TypeParameterElementImpl typeParamElement =
          ElementFactory.typeParameterElement('T');
      typeParamElement.bound = functionType;
      DartType typeParam = typeParamElement.type;
      _checkLeastUpperBound(typeParam, simpleFunctionType, functionType);
    }
  
    void test_typeParam_function_noBound() {
      DartType typeParam = ElementFactory.typeParameterElement('T').type;
      _checkLeastUpperBound(typeParam, simpleFunctionType, objectType);
    }
  
    void test_typeParam_interface_bounded() {
      DartType typeA = ElementFactory.classElement2('A', []).type;
      DartType typeB = ElementFactory.classElement('B', typeA).type;
      DartType typeC = ElementFactory.classElement('C', typeA).type;
      TypeParameterElementImpl typeParamElement =
          ElementFactory.typeParameterElement('T');
      typeParamElement.bound = typeB;
      DartType typeParam = typeParamElement.type;
      _checkLeastUpperBound(typeParam, typeC, typeA);
    }
  
    void test_typeParam_interface_noBound() {
      DartType typeParam = ElementFactory.typeParameterElement('T').type;
      DartType interfaceType = ElementFactory.classElement2('A', []).type;
      _checkLeastUpperBound(typeParam, interfaceType, objectType);
    }
  
    /// Check least upper bound of the same class with different type parameters.
    void test_typeParameters_different() {
      // class List<int>
  