Add a Pepper IDL generator to the JSON schema compiler.

tools/json_schema_compiler/ppapi_generator_test.py

Index: tools/json_schema_compiler/ppapi_generator_test.py
diff --git a/tools/json_schema_compiler/ppapi_generator_test.py b/tools/json_schema_compiler/ppapi_generator_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..087473d0818b23baa26321fceb503fa11edbb8e9
--- /dev/null
+++ b/tools/json_schema_compiler/ppapi_generator_test.py
@@ -0,0 +1,203 @@
+#!/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, False)
+  dev_generator = ppapi_generator._PpapiGeneratorBase(namespace, True)
+  return namespace, generator, dev_generator
+
+
+class PpapiGeneratorIdlStructsTest(unittest.TestCase):
+  def setUp(self):
+    self.namespace, self.generator, self.dev_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'])

[not at google - send to devlin, 2013/12/09 23:30:58]

assertLess is python 2.7 which has been a problem in the past (for windows,
which uses 2.6), though I saw a post saying we were going to upgrade that. just
a warning. this is probably ok to leave for now.

+    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['MyType1'].properties['int_single']))
+    self.assertEqual('PP_Int32_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['int_array']))
+    self.assertEqual('PP_Optional_Int32', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_int']))
+    self.assertEqual('PP_Optional_Int32_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_int_array']))
+    self.assertEqual('double_t', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['double_single']))
+    self.assertEqual('PP_Double_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['double_array']))
+    self.assertEqual('PP_Optional_Double', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_double']))
+    self.assertEqual('PP_Optional_Double_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_double_array']))
+    self.assertEqual('PP_Var', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['string']))
+    self.assertEqual('PP_String_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['string_array']))
+    self.assertEqual('PP_Var', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_string']))
+    self.assertEqual('PP_Optional_String_Array', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['optional_string_array']))
+
+  def testFormatParamTypeStruct(self):
+    self.assertEqual('PP_Idl_pepper_MyType0', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['struct_single']))
+    self.assertEqual(
+        'PP_Idl_pepper_MyType0_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['struct_array']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_MyType0', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_struct']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_MyType0_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties[
+                'optional_struct_array']))
+
+    self.assertEqual(
+        'PP_Idl_pepper_MyType0_Dev', self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['struct_single']))
+    self.assertEqual(
+        'PP_Idl_pepper_MyType0_Array_Dev', self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['struct_array']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_MyType0_Dev',
+        self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_struct']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_MyType0_Array_Dev',
+        self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties[
+                'optional_struct_array']))
+
+  def testFormatParamTypeEnum(self):
+    self.assertEqual('PP_Idl_pepper_EnumType', self.generator.FormatParamType(
+        self.namespace.types['MyType1'].properties['enum_single']))
+    self.assertEqual(
+        'PP_Idl_pepper_EnumType_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['enum_array']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_EnumType', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_enum']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_EnumType_Array', self.generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_enum_array']))
+
+    self.assertEqual(
+        'PP_Idl_pepper_EnumType_Dev', self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['enum_single']))
+    self.assertEqual(
+        'PP_Idl_pepper_EnumType_Array_Dev', self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['enum_array']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_EnumType_Dev',
+        self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_enum']))
+    self.assertEqual(
+        'PP_Optional_Idl_pepper_EnumType_Array_Dev',
+        self.dev_generator.FormatParamType(
+            self.namespace.types['MyType1'].properties['optional_enum_array']))
+
+  def testEnumValueName(self):
+    enum_type = self.namespace.types['EnumType']
+    self.assertEqual('PP_IDL_PEPPER_ENUMTYPE_NAME1',
+                     self.generator.EnumValueName(enum_type.enum_values[0],
+                                                  enum_type))
+    self.assertEqual('PP_IDL_PEPPER_ENUMTYPE_NAME2',
+                     self.generator.EnumValueName(enum_type.enum_values[1],
+                                                  enum_type))
+    enum_type = self.namespace.types['AnotherEnumType']
+    self.assertEqual('PP_IDL_PEPPER_ANOTHERENUMTYPE_NAME1',
+                     self.generator.EnumValueName(enum_type.enum_values[0],
+                                                  enum_type))
+    self.assertEqual('PP_IDL_PEPPER_ANOTHERENUMTYPE_NAME2',
+                     self.generator.EnumValueName(enum_type.enum_values[1],
+                                                  enum_type))
+
+  def testReturnsTypes(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 testDevSuffix(self):
+    self.assertEqual('Foo_Dev', self.dev_generator.AddDevSuffix('Foo'))
+    self.assertEqual('Foo', self.generator.AddDevSuffix('Foo'))
+
+if __name__ == '__main__':
+  unittest.main()