Add missing test coverage for constructor kinds, generic function typedefs and generic mixin applic…

tests/lib/mirrors/generic_function_typedef_test.dart

Index: tests/lib/mirrors/generic_function_typedef_test.dart
diff --git a/tests/lib/mirrors/generic_function_typedef_test.dart b/tests/lib/mirrors/generic_function_typedef_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..8d80017aa92e634f4ce1413c89ad8fd484cc7bdb
--- /dev/null
+++ b/tests/lib/mirrors/generic_function_typedef_test.dart
@@ -0,0 +1,87 @@
+// 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.
+
+library test.generic_function_typedef;
+
+import 'dart:mirrors';
+
+import 'package:expect/expect.dart';
+
+import 'generics_test.dart';
+
+typedef bool NonGenericPredicate(num);
+typedef bool GenericPredicate<T>(T);
+typedef S GenericTransform<S>(S);
+
+class C {
+  GenericPredicate<num> predicateOfNum;
+  GenericTransform<String> transformOfString;
+}
+
+main() {
+  TypeMirror dynamicMirror = currentMirrorSystem().dynamicType;
+
+  TypedefMirror predicateOfNum = reflectClass(C).variables[#predicateOfNum].type;
+  TypedefMirror transformOfString = reflectClass(C).variables[#transformOfString].type;
+
+  // Typedefs.
+  typeParameters(reflectClass(NonGenericPredicate), []);
+  typeParameters(reflectClass(GenericPredicate), [#T]);
+  typeParameters(reflectClass(GenericTransform), [#S]);
+  typeParameters(predicateOfNum, [#T]);
+  typeParameters(transformOfString, [#S]);
+    
+  typeArguments(reflectClass(NonGenericPredicate), []);
+  typeArguments(reflectClass(GenericPredicate), []);
+  typeArguments(reflectClass(GenericTransform), []);
+  typeArguments(predicateOfNum, [reflectClass(num)]);
+  typeArguments(transformOfString, [reflectClass(String)]);
+
+  Expect.isTrue(reflectClass(NonGenericPredicate).isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericPredicate).isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericTransform).isOriginalDeclaration);  
+  Expect.isFalse(predicateOfNum.isOriginalDeclaration);  
+  Expect.isFalse(transformOfString.isOriginalDeclaration);  
+ 
+  // Function types.
+  typeParameters(reflectClass(NonGenericPredicate).referent, []);
+  typeParameters(reflectClass(GenericPredicate).referent, []);
+  typeParameters(reflectClass(GenericTransform).referent, []);
+  typeParameters(predicateOfNum.referent, []);
+  typeParameters(transformOfString.referent, []);
+
+  typeArguments(reflectClass(NonGenericPredicate).referent, []);
+  typeArguments(reflectClass(GenericPredicate).referent, []);
+  typeArguments(reflectClass(GenericTransform).referent, []);
+  typeArguments(predicateOfNum.referent, []);
+  typeArguments(transformOfString.referent, []);
+
+  Expect.isTrue(reflectClass(NonGenericPredicate).referent.isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericPredicate).referent.isOriginalDeclaration);
+  Expect.isTrue(reflectClass(GenericTransform).referent.isOriginalDeclaration);  
+  Expect.isTrue(predicateOfNum.referent.isOriginalDeclaration);  

[gbracha, 2013/10/02 20:57:14]

Subtle, but correct. It would be worth adding a comment explaining why this is
so.

+  Expect.isTrue(transformOfString.referent.isOriginalDeclaration); 
+
+  Expect.equals(reflectClass(num),
+                reflectClass(NonGenericPredicate).referent.parameters[0].type);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericPredicate).referent.parameters[0].type);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericTransform).referent.parameters[0].type);
+  Expect.equals(dynamicMirror,
+                predicateOfNum.referent.parameters[0].type);

[gbracha, 2013/10/02 20:57:14]

Er, why isn't this num?

+  Expect.equals(dynamicMirror,
+                transformOfString.referent.parameters[0].type);

[gbracha, 2013/10/02 20:57:14]

and this String?

+
+  Expect.equals(reflectClass(bool),
+                reflectClass(NonGenericPredicate).referent.returnType);
+  Expect.equals(reflectClass(bool),
+                reflectClass(GenericPredicate).referent.returnType);
+  Expect.equals(dynamicMirror,
+                reflectClass(GenericTransform).referent.returnType);
+  Expect.equals(reflectClass(bool),
+                predicateOfNum.referent.returnType);
+  Expect.equals(dynamicMirror,
+                transformOfString.referent.returnType);

[gbracha, 2013/10/02 20:57:14]

Should be String, no?

+}