Mojom runtime type info: New implementation for Dart.

mojo/dart/unittests/embedder_tests/bindings_generation_test.dart

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:typed_data';
 import 'dart:convert';
 
 import 'package:mojo/bindings.dart' as bindings;
@@ skipping 392 matching lines @@
 }
 
 testValidateMojomTypes() {
   testValidateEnumType();
   testValidateStructType();
   testValidateUnionType();
   testValidateTestStructWithImportType();
   testValidateInterfaceType();
 }
 
+// computeTypeKey encapsulates the algorithm for computing the type key
+// of a type given its fully-qualified name.
+//
+// TODO(rudominer) Delete this when we add accessors for Mojom types
+// in the Dart bindings.
+String computeTypeKey(String fullyQualifiedName) {
+  return "TYPE_KEY:" + fullyQualifiedName;
+}
+
 // Test that mojom type descriptors were generated correctly for validation's
 // BasicEnum.
 testValidateEnumType() {
   var testValidationDescriptor = validation.getAllMojomTypeDefinitions();
-  String enumID = "validation_test_interfaces_BasicEnum__";
   String shortName = "BasicEnum";
   String fullIdentifier = "mojo.test.BasicEnum";
+  String enumID = computeTypeKey(fullIdentifier);
   Map<String, int> labelMap = <String, int>{
     "A": 0,
     "B": 1,
     "C": 0,
     "D": -3,
     "E": 0xA,
   };
 
   // Extract the UserDefinedType from the descriptor using enumID.
   mojom_types.UserDefinedType udt = testValidationDescriptor[enumID];
@@ skipping 17 matching lines @@
     // Check that the enumTypeKey matches the enumID.
     Expect.equals(ev.enumTypeKey, enumID);
     Expect.equals(ev.intValue, labelMap[ev.declData.shortName]);
   });
 }
 
 // Test that mojom type descriptors were generated correctly for validation's
 // StructE.
 testValidateStructType() {
   var testValidationDescriptor = validation.getAllMojomTypeDefinitions();
-  String structID = "validation_test_interfaces_StructE__";
   String shortName = "StructE";
   String fullIdentifier = "mojo.test.StructE";
+  String structID = computeTypeKey(fullIdentifier);
   Map<int, String> expectedFields = <int, String>{
-    0: "StructD",
-    1: "DataPipeConsumer",
+    0: "struct_d",
+    1: "data_pipe_consumer",
   };
 
   // Extract the UserDefinedType from the descriptor using structID.
   mojom_types.UserDefinedType udt = testValidationDescriptor[structID];
   Expect.isNotNull(udt);
 
   // The structType must be present and declared properly.
   mojom_types.MojomStruct ms = udt.structType;
   Expect.isNotNull(ms);
   Expect.isNotNull(ms.declData);
@@ skipping 10 matching lines @@
     Expect.equals(expectedFields[i], field.declData.shortName);
 
     // Special case each field since we already know what should be inside.
     switch (i) {
       case 0: // This is a TypeReference to StructD.
         mojom_types.Type t = field.type;
         Expect.isNotNull(t.typeReference);
 
         // Type key, identifier, and expected reference id should match up.
         mojom_types.TypeReference tr = t.typeReference;
-        String expectedRefID = "validation_test_interfaces_StructD__";
-        Expect.equals(expectedRefID, tr.identifier);
+        String expectedRefID = computeTypeKey("mojo.test.StructD");
+        Expect.equals("StructD", tr.identifier);
         Expect.equals(expectedRefID, tr.typeKey);
         break;
       case 1: // This is a non-nullable DataPipeConsumer HandleType.
         mojom_types.Type t = field.type;
         Expect.isNotNull(t.handleType);
 
         mojom_types.HandleType ht = t.handleType;
         Expect.isFalse(ht.nullable);
         Expect.equals(mojom_types.HandleTypeKind.dataPipeConsumer, ht.kind);
         break;
       default:
         assert(false);
     }
 
     i++;
   });
 }
 
 // Test that mojom type descriptors were generated correctly for validation's
 // UnionB.
 testValidateUnionType() {
   var testValidationDescriptor = validation.getAllMojomTypeDefinitions();
-  String unionID = "validation_test_interfaces_UnionB__";
   String shortName = "UnionB";
   String fullIdentifier = "mojo.test.UnionB";
+  String unionID = computeTypeKey(fullIdentifier);
   Map<int, String> expectedFields = <int, String>{
-    0: "A",
-    1: "B",
-    2: "C",
-    3: "D",
+    0: "a",
+    1: "b",
+    2: "c",
+    3: "d",
   };
 
   // Extract the UserDefinedType from the descriptor using unionID.
   mojom_types.UserDefinedType udt = testValidationDescriptor[unionID];
   Expect.isNotNull(udt);
 
   // The unionType must be present and declared properly.
   mojom_types.MojomUnion mu = udt.unionType;
   Expect.isNotNull(mu);
   Expect.isNotNull(mu.declData);
   Expect.equals(mu.declData.shortName, shortName);
   Expect.equals(mu.declData.fullIdentifier, fullIdentifier);
 
   // Now compare the fields to verify that the union fields match the expected
   // ones.
   Expect.equals(mu.fields.length, expectedFields.length);
+  // TODO(rudominer) Currently ordinal tags in enums are not being populated by
+  // the Mojom parser in mojom_types.mojom so for now we must assume that
+  // the ordinals are in sequential order (which they are in the .mojom
+  // file being used for this test.)
+  int nextOrdinal = 0;
   mu.fields.forEach((mojom_types.UnionField field) {
-    int ordinal = field.tag;
+    int ordinal = nextOrdinal;
+    nextOrdinal++;
 
     // Check that the declData is correct...
     Expect.isNotNull(field.declData);
     Expect.equals(expectedFields[ordinal], field.declData.shortName);
 
     // Special: It turns out that all types are simple types.
     mojom_types.Type t = field.type;
     Expect.isNotNull(t.simpleType);
     mojom_types.SimpleType st = t.simpleType;
 
@@ skipping 12 matching lines @@
       default:
         assert(false);
     }
   });
 }
 
 // Test that mojom type descriptors were generated correctly for validation's
 // IncludingStruct, which contains a union imported from test_included_unions.
 testValidateTestStructWithImportType() {
   var testUnionsDescriptor = unions.getAllMojomTypeDefinitions();
-  String structID = "test_unions_IncludingStruct__";
   String shortName = "IncludingStruct";
   String fullIdentifier = "mojo.test.IncludingStruct";
-  Map<int, String> expectedFields = <int, String>{0: "A",};
+  String structID = computeTypeKey(fullIdentifier);
+  Map<int, String> expectedFields = <int, String>{0: "a",};
 
   // Extract the UserDefinedType from the descriptor using structID.
   mojom_types.UserDefinedType udt = testUnionsDescriptor[structID];
   Expect.isNotNull(udt);
 
   // The structType must be present and declared properly.
   mojom_types.MojomStruct ms = udt.structType;
   Expect.isNotNull(ms);
   Expect.isNotNull(ms.declData);
   Expect.equals(ms.declData.shortName, shortName);
   Expect.equals(ms.declData.fullIdentifier, fullIdentifier);
 
   // Now compare the fields to verify that the struct fields match the expected
   // ones.
   Expect.equals(ms.fields.length, expectedFields.length);
   int i = 0;
   ms.fields.forEach((mojom_types.StructField field) {
     // Check that the declData is correct...
     Expect.isNotNull(field.declData);
     Expect.equals(expectedFields[i], field.declData.shortName);
 
     // Special case each field since we already know what should be inside.
     switch (i) {
       case 0: // This is a TypeReference to a Union.
         mojom_types.Type t = field.type;
         Expect.isNotNull(t.typeReference);
 
         // Type key, identifier, and expected reference id should match up.
         mojom_types.TypeReference tr = t.typeReference;
-        String expectedRefID = "test_included_unions_IncludedUnion__";
-        Expect.equals(expectedRefID, tr.identifier);
+        String expectedRefID = computeTypeKey("mojo.test.IncludedUnion");
+        Expect.equals("IncludedUnion", tr.identifier);
         Expect.equals(expectedRefID, tr.typeKey);
         break;
       default:
         assert(false);
     }
 
     i++;
   });
 }
 
 // Test that mojom type descriptors were generated correctly for validation's
 // BoundsCheckTestInterface.
 testValidateInterfaceType() {
   // interface BoundsCheckTestInterface {
   //   Method0(uint8 param0) => (uint8 param0);
   //   Method1(uint8 param0);
   // };
 
   var testValidationDescriptor = validation.getAllMojomTypeDefinitions();
-  String interfaceID = "validation_test_interfaces_BoundsCheckTestInterface__";
   String shortName = "BoundsCheckTestInterface";
   String fullIdentifier = "mojo.test.BoundsCheckTestInterface";
+  String interfaceID = computeTypeKey(fullIdentifier);
   Map<int, String> methodMap = <int, String>{0: "Method0", 1: "Method1",};
 
   mojom_types.UserDefinedType udt = testValidationDescriptor[interfaceID];
   Expect.isNotNull(udt);
 
   mojom_types.MojomInterface mi = udt.interfaceType;
   Expect.isNotNull(mi);
 
   _checkMojomInterface(mi, shortName, fullIdentifier, methodMap);
 
@@ skipping 99 matching lines @@
   testValidateMojomTypes();
   testCamelCase();
   testSerializeErrorMessage();
   await testEnums();
   await testCallResponse();
   await testAwaitCallResponse();
   await runOnClosedTest();
   await testRegression551();
   await testServiceName();
 }