Generate Mojom Types in Dart (Take 2)

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;
 import 'package:mojo/core.dart' as core;
+import 'package:mojo/mojo/bindings/types/mojom_types.mojom.dart' as mojom_types;
+import 'package:mojo/mojo/bindings/types/service_describer.mojom.dart'
+    as service_describer;
 import 'package:_mojo_for_test_only/expect.dart';
 import 'package:_mojo_for_test_only/mojo/test/rect.mojom.dart' as rect;
 import 'package:_mojo_for_test_only/mojo/test/serialization_test_structs.mojom.dart'
     as serialization;
 import 'package:_mojo_for_test_only/mojo/test/test_structs.mojom.dart'
     as structs;
 import 'package:_mojo_for_test_only/mojo/test/test_unions.mojom.dart'
     as unions;
+import 'package:_mojo_for_test_only/mojo/test/validation_test_interfaces.mojom.dart'
+    as validation;
 import 'package:_mojo_for_test_only/regression_tests/regression_tests.mojom.dart'
     as regression;
 import 'package:_mojo_for_test_only/sample/sample_interfaces.mojom.dart'
     as sample;
 
 class ProviderImpl implements sample.Provider {
   sample.ProviderStub _stub;
 
   ProviderImpl(core.MojoMessagePipeEndpoint endpoint) {
     _stub = new sample.ProviderStub.fromEndpoint(endpoint, this);
   }
 
   echoString(String a, Function responseFactory) =>
       new Future.value(responseFactory(a));
 
   echoStrings(String a, String b, Function responseFactory) =>
       new Future.value(responseFactory(a, b));
 
-  echoMessagePipeHanlde(core.MojoHandle a, Function responseFactory) =>
+  echoMessagePipeHandle(core.MojoHandle a, Function responseFactory) =>
       new Future.value(responseFactory(a));
 
   echoEnum(sample.Enum a, Function responseFactory) =>
       new Future.value(responseFactory(a));
 }
 
 void providerIsolate(core.MojoMessagePipeEndpoint endpoint) {
   new ProviderImpl(endpoint);
 }
 
@@ skipping 333 matching lines @@
   e = CamelCaseTestEnum.int8Thing;
   e = CamelCaseTestEnum.int16Thing;
   e = CamelCaseTestEnum.int32Th1Ng;
   e = CamelCaseTestEnum.int64Th1ng;
   e = CamelCaseTestEnum.uint8TH1ng;
   e = CamelCaseTestEnum.uint16tH1Ng;
   e = CamelCaseTestEnum.uint32Th1ng;
   e = CamelCaseTestEnum.uint64Th1Ng;
 }
 
+testValidateMojomTypes() {
+  testValidateEnumType();
+  testValidateStructType();
+  testValidateUnionType();
+  testValidateTestStructWithImportType();
+  testValidateInterfaceType();
+}
+
+// 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";
+  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];
+  Expect.isNotNull(udt);
+
+  // The enumType must be present and declared properly.
+  mojom_types.MojomEnum me = udt.enumType;
+  Expect.isNotNull(me);
+  Expect.isNotNull(me.declData);
+  Expect.equals(me.declData.shortName, shortName);
+  Expect.equals(me.declData.fullIdentifier, fullIdentifier);
+
+  // Now compare the labels to verify that the enum labels match the expected
+  // ones.
+  Expect.equals(me.values.length, labelMap.length);
+  me.values.forEach((mojom_types.EnumValue ev) {
+    // Check that the declData is correct...
+    Expect.isNotNull(ev.declData);
+    Expect.isNotNull(labelMap[ev.declData.shortName]);
+
+    // 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";
+  Map<int, String> expectedFields = <int, String>{
+    0: "StructD",
+    1: "DataPipeConsumer",
+  };
+
+  // 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);
+  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 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);
+        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";
+  Map<int, String> expectedFields = <int, String>{
+    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);
+  mu.fields.forEach((mojom_types.UnionField field) {
+    int ordinal = field.tag;
+
+    // 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;
+
+    // Special case each field since we already know what should be inside.
+    switch (ordinal) {
+      case 0: // Uint16
+        Expect.equals(st, mojom_types.SimpleType.uint16);
+        break;
+      case 1: // Uint32
+      case 3:
+        Expect.equals(st, mojom_types.SimpleType.uint32);
+        break;
+      case 2: // Uint64
+        Expect.equals(st, mojom_types.SimpleType.uint64);
+        break;
+      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",};
+
+  // 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);
+        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";
+  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);
+
+  // The proxy and stub need to have a valid serviceDescription.
+  var bcti_p = new validation.BoundsCheckTestInterfaceProxy.unbound().impl;
+  var bcti_s = new validation.BoundsCheckTestInterfaceStub.unbound();
+
+  _checkServiceDescription(
+      bcti_p.serviceDescription, interfaceID, shortName, fullIdentifier,
+      methodMap);
+  _checkServiceDescription(
+      bcti_s.serviceDescription, interfaceID, shortName, fullIdentifier,
+      methodMap);
+}
+
+_checkServiceDescription(service_describer.ServiceDescription sd,
+    String interfaceID, String shortName, String fullIdentifier,
+    Map<int, String> methodMap) {
+  // Check the top level interface, which must pass _checkMojomInterface.
+  mojom_types.MojomInterface mi = sd.getTopLevelInterface();
+  _checkMojomInterface(mi, shortName, fullIdentifier, methodMap);
+
+  // Try out sd.GetTypeDefinition with the given interfaceID.
+  mojom_types.UserDefinedType udt = sd.getTypeDefinition(interfaceID);
+  Expect.isNotNull(udt.interfaceType);
+  _checkMojomInterface(udt.interfaceType, shortName, fullIdentifier, methodMap);
+
+  // Check all type definitions. Reflect-wise, all data inside should match the
+  // imported Descriptor.
+  var actualDescriptions = sd.getAllTypeDefinitions();
+  var expectedDescriptions = validation.getAllMojomTypeDefinitions();
+  Expect.mapEquals(actualDescriptions, expectedDescriptions);
+}
+
+_checkMojomInterface(mojom_types.MojomInterface mi, String shortName,
+    String fullIdentifier, Map<int, String> methodMap) {
+  // check the generated short name.
+  Expect.isNotNull(mi.declData);
+  Expect.equals(mi.declData.shortName, shortName);
+  Expect.equals(mi.declData.fullIdentifier, fullIdentifier);
+
+  // Verify that the number of methods matches the expected ones.
+  Expect.equals(mi.methods.length, methodMap.length);
+
+  // Each MojomMethod must be named, typed, and "ordinal"ed correctly.
+  mi.methods.forEach((int ordinal, mojom_types.MojomMethod method) {
+    Expect.isNotNull(method.declData);
+    Expect.equals(methodMap[ordinal], method.declData.shortName);
+
+    // Special case each method since we know what's inside.
+    switch (ordinal) {
+      case 0: // Has request and response params.
+        // Request is a single uint8 input.
+        mojom_types.MojomStruct params = method.parameters;
+        Expect.equals(params.fields.length, 1);
+        Expect.equals(
+            params.fields[0].type.simpleType, mojom_types.SimpleType.uint8);
+
+        // Response is a single uint8 output.
+        mojom_types.MojomStruct response = method.responseParams;
+        Expect.isNotNull(response);
+        Expect.equals(response.fields.length, 1);
+        Expect.equals(
+            response.fields[0].type.simpleType, mojom_types.SimpleType.uint8);
+        break;
+      case 1: // Only has request params.
+        // Request is a single uint8 input.
+        mojom_types.MojomStruct params = method.parameters;
+        Expect.equals(params.fields.length, 1);
+        Expect.equals(
+            params.fields[0].type.simpleType, mojom_types.SimpleType.uint8);
+
+        // Response is a single uint8 output.
+        mojom_types.MojomStruct response = method.responseParams;
+        Expect.isNull(response);
+        break;
+      default:
+        assert(false);
+    }
+  });
+}
+
 
 main() async {
   testSerializeStructs();
   testUnions();
+  testValidateMojomTypes();
   await testEnums();
   await testCallResponse();
   await testAwaitCallResponse();
   await runOnClosedTest();
   await testRegression551();
   await testServiceName();
   testCamelCase();
 }