Add a Pepper IDL generator to the JSON schema compiler.

tools/json_schema_compiler/ppapi_generator_test.py

+#!/usr/bin/env python
+# Copyright 2013 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 os
+import unittest
+
+from model import Model
+import ppapi_generator
+from schema_loader import SchemaLoader
+
+
+def _LoadNamespace(filename):
+  filename = os.path.join(os.path.dirname(__file__), filename)
+  schema_loader = SchemaLoader(
+      os.path.dirname(os.path.relpath(os.path.normpath(filename),
+                                      os.path.dirname(filename))),
+      os.path.dirname(filename))
+  schema = os.path.normpath(filename)
+  api_def = schema_loader.LoadSchema(os.path.split(schema)[1])[0]
+
+  api_model = Model()
+  relpath = os.path.relpath(os.path.normpath(filename),
+                            os.path.dirname(filename))
+  namespace = api_model.AddNamespace(api_def, relpath)
+  generator = ppapi_generator._PpapiGeneratorBase(namespace)
+  return namespace, generator
+
+
+class PpapiGeneratorIdlStructsTest(unittest.TestCase):
+  def setUp(self):
+    self.namespace, self.generator = _LoadNamespace(
+        os.path.join('test', 'idl_pepper.idl'))
+
+  def testTypesOrder(self):
+    typename_to_index = dict(
+        (type_.name, i) for i, type_ in enumerate(self.generator._types))
+    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType2'])
+    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType3'])
+    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType4'])
+    self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType5'])
+    self.assertLess(typename_to_index['MyType3'], typename_to_index['MyType5'])
+    self.assertLess(typename_to_index['MyType4'], typename_to_index['MyType5'])
+    self.assertLess(typename_to_index['MyType5'], typename_to_index['MyType6'])
+
+  def testNeedsArray(self):
+    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType1']))
+    self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType2']))
+    self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType3']))
+    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType4']))
+    self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType5']))
+    self.assertTrue(self.generator.NeedsArray(self.namespace.types['EnumType']))
+
+  def testNeedsOptional(self):
+    self.assertFalse(
+        self.generator.NeedsOptional(self.namespace.types['MyType1']))
+    self.assertFalse(
+        self.generator.NeedsOptional(self.namespace.types['MyType2']))
+    self.assertTrue(
+        self.generator.NeedsOptional(self.namespace.types['MyType3']))
+    self.assertTrue(
+        self.generator.NeedsOptional(self.namespace.types['MyType4']))
+    self.assertFalse(
+        self.generator.NeedsOptional(self.namespace.types['MyType5']))
+    self.assertTrue(
+        self.generator.NeedsOptional(self.namespace.types['EnumType']))
+
+  def testNeedsOptionalArray(self):
+    self.assertFalse(
+        self.generator.NeedsOptionalArray(self.namespace.types['MyType1']))
+    self.assertTrue(
+        self.generator.NeedsOptionalArray(self.namespace.types['MyType2']))
+    self.assertFalse(
+        self.generator.NeedsOptionalArray(self.namespace.types['MyType3']))
+    self.assertFalse(
+        self.generator.NeedsOptionalArray(self.namespace.types['MyType4']))
+    self.assertFalse(
+        self.generator.NeedsOptionalArray(self.namespace.types['MyType5']))
+    self.assertTrue(
+        self.generator.NeedsOptionalArray(self.namespace.types['EnumType']))
+
+  def testFormatParamTypePrimitive(self):
+    self.assertEqual('int32_t', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['int_single']))
+    self.assertEqual('PP_Int32_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['int_array']))
+    self.assertEqual('PP_Optional_Int32', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_int']))
+    self.assertEqual('PP_Optional_Int32_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_int_array']))
+    self.assertEqual('double_t', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['double_single']))
+    self.assertEqual('PP_Double_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['double_array']))
+    self.assertEqual('PP_Optional_Double', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_double']))
+    self.assertEqual('PP_Optional_Double_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_double_array']))
+    self.assertEqual('PP_Var', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['string']))
+    self.assertEqual('PP_String_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['string_array']))
+    self.assertEqual('PP_Var', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_string']))
+    self.assertEqual('PP_Optional_String_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['optional_string_array']))
+
+  def testFormatParamTypeStruct(self):
+    self.assertEqual('PP_IdlPepper_MyType0', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['struct_single']))
+    self.assertEqual(
+        'PP_IdlPepper_MyType0_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties['struct_array']))
+    self.assertEqual(
+        'PP_IdlPepper_Optional_MyType0', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties['optional_struct']))
+    self.assertEqual(
+        'PP_IdlPepper_Optional_MyType0_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties[
+                'optional_struct_array']))
+
+  def testFormatParamTypeEnum(self):
+    self.assertEqual('PP_IdlPepper_EnumType', self.generator.FormatParamType(
+        self.namespace.types['MyType'].properties['enum_single']))
+    self.assertEqual(
+        'PP_IdlPepper_EnumType_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties['enum_array']))
+    self.assertEqual(
+        'PP_IdlPepper_Optional_EnumType', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties['optional_enum']))
+    self.assertEqual(
+        'PP_IdlPepper_Optional_EnumType_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType'].properties['optional_enum_array']))
+
+  def testEnumValueName(self):
+    enum_type = self.namespace.types['EnumType']
+    self.assertEqual('PP_IDLPEPPER_ENUMTYPE_NAME1',
+                     self.generator.EnumValueName(enum_type.enum_values[0],
+                                                  enum_type))
+    self.assertEqual('PP_IDLPEPPER_ENUMTYPE_NAME2',
+                     self.generator.EnumValueName(enum_type.enum_values[1],
+                                                  enum_type))
+    enum_type = self.namespace.types['AnotherEnumType']
+    self.assertEqual('PP_IDLPEPPER_ANOTHERENUMTYPE_NAME1',
+                     self.generator.EnumValueName(enum_type.enum_values[0],
+                                                  enum_type))
+    self.assertEqual('PP_IDLPEPPER_ANOTHERENUMTYPE_NAME2',
+                     self.generator.EnumValueName(enum_type.enum_values[1],
+                                                  enum_type))
+
+  def testReturnTypes(self):
+    self.assertEqual('void', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function1']))
+    self.assertEqual('void', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function2']))
+    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function3']))
+    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function4']))
+    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function5']))
+    self.assertEqual('int32_t', self.generator.GetFunctionReturnType(
+        self.namespace.functions['function6']))
+
+  def testHasOutArray(self):
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function1']))
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function2']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function3']))
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function4']))
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function5']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function6']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function7']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function8']))
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function9']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function10']))
+    self.assertTrue(self.generator.HasArrayOuts(
+        self.namespace.functions['function11']))
+    self.assertFalse(self.generator.HasArrayOuts(
+        self.namespace.functions['function12']))
+
+if __name__ == '__main__':
+  unittest.main()