// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

// @dart = 2.9

// Test expectations for 'class_mirror_type_variables_data.dart'.

library class_mirror_type_variables_expect;

import "dart:mirrors";

import "package:expect/expect.dart";

/// The interface of [Env] is shared between the runtime and the source mirrors
/// test.
abstract class Env {
  ClassMirror getA();
  ClassMirror getB();
  ClassMirror getC();
  ClassMirror getD();
  ClassMirror getE();
  ClassMirror getF();
  ClassMirror getNoTypeParams();
  ClassMirror getObject();
  ClassMirror getString();
  ClassMirror getHelperOfString();
}

void test(Env env) {
  testNoTypeParams(env);
  testA(env);
  testBAndC(env);
  testD(env);
  testE(env);
  testF(env);
}

testNoTypeParams(Env env) {
  ClassMirror cm = env.getNoTypeParams();
  Expect.equals(cm.typeVariables.length, 0);
}

void testA(Env env) {
  ClassMirror a = env.getA();
  Expect.equals(2, a.typeVariables.length);

  TypeVariableMirror aT = a.typeVariables[0];
  TypeVariableMirror aS = a.typeVariables[1];
  ClassMirror aTBound = aT.upperBound as ClassMirror;
  ClassMirror aSBound = aS.upperBound as ClassMirror;

  Expect.isTrue(aTBound.isOriginalDeclaration);
  Expect.isTrue(aSBound.isOriginalDeclaration);

  Expect.equals(env.getObject(), aTBound);
  Expect.equals(env.getString(), aSBound);
}

void testBAndC(Env env) {
  ClassMirror b = env.getB();
  ClassMirror c = env.getC();

  Expect.equals(1, b.typeVariables.length);
  Expect.equals(1, c.typeVariables.length);

  TypeVariableMirror bZ = b.typeVariables[0];
  TypeVariableMirror cZ = c.typeVariables[0];
  ClassMirror bZBound = bZ.upperBound as ClassMirror;
  ClassMirror cZBound = cZ.upperBound as ClassMirror;

  Expect.isFalse(bZBound.isOriginalDeclaration);
  Expect.isFalse(cZBound.isOriginalDeclaration);

  Expect.equals(b, bZBound.originalDeclaration);
  Expect.equals(b, cZBound.originalDeclaration);

  TypeMirror bZBoundTypeArgument = bZBound.typeArguments.single;
  TypeMirror cZBoundTypeArgument = cZBound.typeArguments.single;
  TypeVariableMirror bZBoundTypeVariable = bZBound.typeVariables.single;
  TypeVariableMirror cZBoundTypeVariable = cZBound.typeVariables.single;

  Expect.equals(b, bZ.owner);
  Expect.equals(c, cZ.owner);
  Expect.equals(b, bZBoundTypeVariable.owner);
  Expect.equals(b, cZBoundTypeVariable.owner);

  Expect.equals(bZ, bZBoundTypeArgument);
  Expect.equals(cZ, cZBoundTypeArgument);
  Expect.equals(bZ, bZBoundTypeVariable);
  Expect.equals(bZ, cZBoundTypeVariable);
}

testD(Env env) {
  ClassMirror cm = env.getD();
  Expect.equals(3, cm.typeVariables.length);
  var values = cm.typeVariables;
  values.forEach((e) {
    Expect.equals(true, e is TypeVariableMirror);
  });

  // Names of type variables are not preserved after type canonicalization
  // and are therefore not compared to expected names.
}

void testE(Env env) {
  ClassMirror e = env.getE();
  TypeVariableMirror eR = e.typeVariables.single;
  ClassMirror mapRAndHelperOfString = eR.upperBound as ClassMirror;

  Expect.isFalse(mapRAndHelperOfString.isOriginalDeclaration);
  Expect.equals(eR, mapRAndHelperOfString.typeArguments.first);
  Expect.equals(
      env.getHelperOfString(), mapRAndHelperOfString.typeArguments.last);
}

void testF(Env env) {
  ClassMirror f = env.getF();
  TypeVariableMirror fZ = f.typeVariables[0];
  ClassMirror fZBound = fZ.upperBound as ClassMirror;
  ClassMirror fZBoundTypeArgument = fZBound.typeArguments.single as ClassMirror;

  Expect.equals(1, f.typeVariables.length);
  Expect.isFalse(fZBound.isOriginalDeclaration);
  Expect.isFalse(fZBoundTypeArgument.isOriginalDeclaration);
  Expect.equals(f, fZBoundTypeArgument.originalDeclaration);
  Expect.equals(fZ, fZBoundTypeArgument.typeArguments.single);
}