Improves the representation of values in Mojom.

mojo/public/tools/bindings/pylib/mojom/generate/mojom_translator_unittests.py

 # Copyright 2015 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.
 #
 # The first argument of this script should be the location of both
 # the generated mojom_files and mojom_types modules and their dependencies.
 
 def _FixPath():
   import sys
   # Importing mojom_files_mojom, mojom_types_mojom and mojom_translator
@@ skipping 86 matching lines @@
           short_name='AnEnum',
           source_file_info=mojom_types_mojom.SourceFileInfo(
             file_name=file_name)))
     graph.resolved_types['enum_key'] = mojom_types_mojom.UserDefinedType(
         enum_type=mojom_enum)
 
     mojom_const = mojom_types_mojom.DeclaredConstant(
         decl_data=mojom_types_mojom.DeclarationData(short_name='AConst'),
         type=mojom_types_mojom.Type(
           simple_type=mojom_types_mojom.SimpleType.INT64),
-        value=mojom_types_mojom.ConstantOccurrence(
-          value=mojom_types_mojom.ConstantValue(
+        value=mojom_types_mojom.Value(
+          literal_value=mojom_types_mojom.LiteralValue(
             int64_value=30)))
-    graph.resolved_constants = {'const_key': mojom_const}
+    user_defined_value = mojom_types_mojom.UserDefinedValue()
+    user_defined_value.declared_constant = mojom_const
+    graph.resolved_values = {'value_key': user_defined_value}
 
     mojom_file.declared_mojom_objects = mojom_files_mojom.KeysByType(
         interfaces=['interface_key'],
         structs=['struct_key'],
         unions=['union_key'],
         top_level_enums=['enum_key'],
-        top_level_constants=['const_key']
+        top_level_constants=['value_key']
         )
 
     mod = mojom_translator.FileTranslator(graph, file_name).Translate()
 
     self.assertEquals('f.mojom', mod.name)
     self.assertEquals(mojom_file.file_name, mod.path)
     self.assertEquals(mojom_file.module_namespace, mod.namespace)
 
     self.assertEquals('a.mojom', mod.imports[0]['module_name'])
     self.assertEquals(imported_file.module_namespace,
@@ skipping 24 matching lines @@
           decl_data=mojom_types_mojom.DeclarationData(
             short_name='field01',
             declared_ordinal=5),
           type=mojom_types_mojom.Type(
             simple_type=mojom_types_mojom.SimpleType.BOOL)),
         mojom_types_mojom.StructField(
           decl_data=mojom_types_mojom.DeclarationData(
             short_name='field02'),
           type=mojom_types_mojom.Type(
             simple_type=mojom_types_mojom.SimpleType.DOUBLE),
-          default_value=mojom_types_mojom.ConstantOccurrence(
-            value=mojom_types_mojom.ConstantValue(double_value=15))),
+          default_value=mojom_types_mojom.DefaultFieldValue(
+            value=mojom_types_mojom.Value(
+              literal_value=mojom_types_mojom.LiteralValue(double_value=15)))),
         ]
     mojom_struct.decl_data.source_file_info = mojom_types_mojom.SourceFileInfo(
         file_name=mojom_file.file_name)
 
     struct = module.Struct()
     translator = mojom_translator.FileTranslator(graph, file_name)
     translator.StructFromMojom(
         struct, mojom_types_mojom.UserDefinedType(struct_type=mojom_struct))
 
     self.assertEquals('FirstStruct', struct.name)
@@ skipping 11 matching lines @@
     self.assertEquals(15, struct.fields[1].default)
 
   def test_constant(self):
     graph = mojom_files_mojom.MojomFileGraph()
 
     mojom_const = mojom_types_mojom.DeclaredConstant()
     mojom_const.decl_data = mojom_types_mojom.DeclarationData(
         short_name='foo')
     mojom_const.type = mojom_types_mojom.Type(
         simple_type=mojom_types_mojom.SimpleType.INT64)
-    mojom_const.value = mojom_types_mojom.ConstantOccurrence()
-    mojom_const.value.value = mojom_types_mojom.ConstantValue(
+    mojom_const.value = mojom_types_mojom.Value()
+    mojom_const.value.literal_value = mojom_types_mojom.LiteralValue(
         int64_value=20)
 
     struct = module.Struct()
     const = mojom_translator.FileTranslator(graph, None).ConstFromMojom(
         mojom_const, struct)
 
     self.assertEquals(mojom_const.decl_data.short_name, const.name)
     self.assertEquals(module.INT64, const.kind)
     self.assertEquals(20, const.value)
     self.assertEquals(struct, const.parent_kind)
 
   def test_enum(self):
     file_name = 'a.mojom'
     mojom_enum = mojom_types_mojom.MojomEnum()
     mojom_enum.decl_data = mojom_types_mojom.DeclarationData(
         short_name='AnEnum',
         source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name))
     value1 = mojom_types_mojom.EnumValue(
         decl_data=mojom_types_mojom.DeclarationData(short_name='val1'),
-        value=mojom_types_mojom.ConstantOccurrence(
-          value=mojom_types_mojom.ConstantValue(int32_value=20)))
+        enum_type_key='AnEnum',
+        int_value=20)
     value2 = mojom_types_mojom.EnumValue(
         decl_data=mojom_types_mojom.DeclarationData(short_name='val2'),
-        value=mojom_types_mojom.ConstantOccurrence(
-          value=mojom_types_mojom.ConstantValue(int32_value=70)))
+        enum_type_key='AnEnum',
+        int_value=70)
     mojom_enum.values = [value1, value2]
 
 
     graph = mojom_files_mojom.MojomFileGraph()
     enum = module.Enum()
     translator = mojom_translator.FileTranslator(graph, file_name)
     translator.EnumFromMojom(
         enum, mojom_types_mojom.UserDefinedType(enum_type=mojom_enum), None)
 
     self.assertEquals(translator._module, enum.module)
     self.assertEquals(mojom_enum.decl_data.short_name, enum.name)
     self.assertEquals(len(mojom_enum.values), len(enum.fields))
 
     self.assertEquals(value1.decl_data.short_name, enum.fields[0].name)
     self.assertEquals(value2.decl_data.short_name, enum.fields[1].name)
 
-    self.assertEquals(value1.value.value.int32_value, enum.fields[0].value)
-    self.assertEquals(value2.value.value.int32_value, enum.fields[1].value)
+    self.assertEquals(value1.int_value, enum.fields[0].value)
+    self.assertEquals(value2.int_value, enum.fields[1].value)
 
-    self.assertEquals(value1.value.value.int32_value,
+    self.assertEquals(value1.int_value,
         enum.fields[0].numeric_value)
-    self.assertEquals(value2.value.value.int32_value,
+    self.assertEquals(value2.int_value,
         enum.fields[1].numeric_value)
 
   def test_unions(self):
     file_name = 'a.mojom'
     mojom_union = mojom_types_mojom.MojomUnion()
     mojom_union.decl_data = mojom_types_mojom.DeclarationData(
         short_name='AUnion',
         source_file_info=mojom_types_mojom.SourceFileInfo(file_name=file_name))
 
     field1 = mojom_types_mojom.UnionField(
@@ skipping 164 matching lines @@
         param1.decl_data.short_name, method.response_parameters[0].name)
 
   def test_parameter(self):
     # Parameters are encoded as fields in a struct.
     mojom_param = mojom_types_mojom.StructField(
         decl_data=mojom_types_mojom.DeclarationData(
           short_name='param0',
           declared_ordinal=5),
         type=mojom_types_mojom.Type(
           simple_type=mojom_types_mojom.SimpleType.UINT64),
-        default_value=mojom_types_mojom.ConstantOccurrence(
-          value=mojom_types_mojom.ConstantValue(uint64_value=20)))
+        default_value=mojom_types_mojom.Value(
+          literal_value=mojom_types_mojom.LiteralValue(uint64_value=20)))
 
     graph = mojom_files_mojom.MojomFileGraph()
     translator = mojom_translator.FileTranslator(graph, '')
     param = translator.ParamFromMojom(mojom_param)
 
     self.assertEquals(mojom_param.decl_data.short_name, param.name)
     self.assertEquals(module.UINT64, param.kind)
     self.assertEquals(mojom_param.decl_data.declared_ordinal, param.ordinal)
-    self.assertEquals(
-        mojom_param.default_value.value.uint64_value, param.default)
 
 
-class TestEvalConst(unittest.TestCase):
+class TestEvalValue(unittest.TestCase):
 
-  def test_resolved_simple(self):
-    mojom = mojom_types_mojom.ConstantOccurrence()
-    mojom.value = mojom_types_mojom.ConstantValue(int64_value=20)
+  def test_literal_value(self):
+    mojom = mojom_types_mojom.Value()
+    mojom.literal_value = mojom_types_mojom.LiteralValue(int64_value=20)
 
     graph = mojom_files_mojom.MojomFileGraph()
-    const = mojom_translator.FileTranslator(graph, None).EvalConst(mojom)
+    const = mojom_translator.FileTranslator(graph, None).EvalValue(mojom)
 
     self.assertEquals(20, const)
 
-  def test_resolved_enum(self):
-    # TODO(azani): Handle resolved enums.
+  def test_resolved_user_defined_values(self):
+    # TODO(azani): Write this.
     pass
 
   def test_builtin_const(self):
-    mojom = mojom_types_mojom.ConstantOccurrence()
-    mojom.value = mojom_types_mojom.ConstantValue()
+    mojom = mojom_types_mojom.Value()
 
     graph = mojom_files_mojom.MojomFileGraph()
 
     gold = [
         (mojom_types_mojom.BuiltinConstantValue.DOUBLE_INFINITY,
           'double.INFINITY'),
         (mojom_types_mojom.BuiltinConstantValue.DOUBLE_NEGATIVE_INFINITY,
           'double.NEGATIVE_INFINITY'),
         (mojom_types_mojom.BuiltinConstantValue.DOUBLE_NAN,
           'double.DOUBLE_NAN'),
         (mojom_types_mojom.BuiltinConstantValue.FLOAT_INFINITY,
           'float.INFINITY'),
         (mojom_types_mojom.BuiltinConstantValue.FLOAT_NEGATIVE_INFINITY,
           'float.NEGATIVE_INFINITY'),
         (mojom_types_mojom.BuiltinConstantValue.FLOAT_NAN, 'float.NAN'),
         ]
 
     for mojom_builtin, string in gold:
-      mojom.value.builtin_value = mojom_builtin
-      const = mojom_translator.FileTranslator(graph, None).EvalConst(mojom)
+      mojom.builtin_value = mojom_builtin
+      const = mojom_translator.FileTranslator(graph, None).EvalValue(mojom)
       self.assertIsInstance(const, module.BuiltinValue)
       self.assertEquals(string, const.value)
 
 
 
 
 # TODO(azani): Set the path of modules correctly.
 
 class TestKindFromMojom(unittest.TestCase):
 
@@ skipping 148 matching lines @@
     result2 = t.KindFromMojom(mojom_type)
     self.assertIs(result, result2)
 
     # Nullable type reference
     mojom_type.type_reference.nullable = True
     nullable_result = t.KindFromMojom(mojom_type)
     self.assertTrue(module.IsNullableKind(nullable_result))
 
 if __name__ == '__main__':
   unittest.main()