Chromium Code Reviews Chromium Code Reviews
Issue 101483003:
Add a Pepper IDL generator to the JSON schema compiler. (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master| OLD | NEW |
|---|---|
| (Empty) | |
| 1 #!/usr/bin/env python | |
| 2 # Copyright 2013 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 import os | |
| 7 import unittest | |
| 8 | |
| 9 from model import Model | |
| 10 import ppapi_generator | |
| 11 from schema_loader import SchemaLoader | |
| 12 | |
| 13 | |
| 14 def _LoadNamespace(filename): | |
| 15 filename = os.path.join(os.path.dirname(__file__), filename) | |
| 16 schema_loader = SchemaLoader( | |
| 17 os.path.dirname(os.path.relpath(os.path.normpath(filename), | |
| 18 os.path.dirname(filename))), | |
| 19 os.path.dirname(filename)) | |
| 20 schema = os.path.normpath(filename) | |
| 21 api_def = schema_loader.LoadSchema(os.path.split(schema)[1])[0] | |
| 22 | |
| 23 api_model = Model() | |
| 24 relpath = os.path.relpath(os.path.normpath(filename), | |
| 25 os.path.dirname(filename)) | |
| 26 namespace = api_model.AddNamespace(api_def, relpath) | |
| 27 generator = ppapi_generator._PpapiGeneratorBase(namespace, False) | |
| 28 dev_generator = ppapi_generator._PpapiGeneratorBase(namespace, True) | |
| 29 return namespace, generator, dev_generator | |
| 30 | |
| 31 | |
| 32 class PpapiGeneratorIdlStructsTest(unittest.TestCase): | |
| 33 def setUp(self): | |
| 34 self.namespace, self.generator, self.dev_generator = _LoadNamespace( | |
| 35 os.path.join('test', 'idl_pepper.idl')) | |
| 36 | |
| 37 def testTypesOrder(self): | |
| 38 typename_to_index = dict( | |
| 39 (type_.name, i) for i, type_ in enumerate(self.generator._types)) | |
| 40 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
| |
| 41 self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType3']) | |
| 42 self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType4']) | |
| 43 self.assertLess(typename_to_index['MyType1'], typename_to_index['MyType5']) | |
| 44 self.assertLess(typename_to_index['MyType3'], typename_to_index['MyType5']) | |
| 45 self.assertLess(typename_to_index['MyType4'], typename_to_index['MyType5']) | |
| 46 self.assertLess(typename_to_index['MyType5'], typename_to_index['MyType6']) | |
| 47 | |
| 48 def testNeedsArray(self): | |
| 49 self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType1'])) | |
| 50 self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType2'])) | |
| 51 self.assertTrue(self.generator.NeedsArray(self.namespace.types['MyType3'])) | |
| 52 self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType4'])) | |
| 53 self.assertFalse(self.generator.NeedsArray(self.namespace.types['MyType5'])) | |
| 54 self.assertTrue(self.generator.NeedsArray(self.namespace.types['EnumType'])) | |
| 55 | |
| 56 def testNeedsOptional(self): | |
| 57 self.assertFalse( | |
| 58 self.generator.NeedsOptional(self.namespace.types['MyType1'])) | |
| 59 self.assertFalse( | |
| 60 self.generator.NeedsOptional(self.namespace.types['MyType2'])) | |
| 61 self.assertTrue( | |
| 62 self.generator.NeedsOptional(self.namespace.types['MyType3'])) | |
| 63 self.assertTrue( | |
| 64 self.generator.NeedsOptional(self.namespace.types['MyType4'])) | |
| 65 self.assertFalse( | |
| 66 self.generator.NeedsOptional(self.namespace.types['MyType5'])) | |
| 67 self.assertTrue( | |
| 68 self.generator.NeedsOptional(self.namespace.types['EnumType'])) | |
| 69 | |
| 70 def testNeedsOptionalArray(self): | |
| 71 self.assertFalse( | |
| 72 self.generator.NeedsOptionalArray(self.namespace.types['MyType1'])) | |
| 73 self.assertTrue( | |
| 74 self.generator.NeedsOptionalArray(self.namespace.types['MyType2'])) | |
| 75 self.assertFalse( | |
| 76 self.generator.NeedsOptionalArray(self.namespace.types['MyType3'])) | |
| 77 self.assertFalse( | |
| 78 self.generator.NeedsOptionalArray(self.namespace.types['MyType4'])) | |
| 79 self.assertFalse( | |
| 80 self.generator.NeedsOptionalArray(self.namespace.types['MyType5'])) | |
| 81 self.assertTrue( | |
| 82 self.generator.NeedsOptionalArray(self.namespace.types['EnumType'])) | |
| 83 | |
| 84 def testFormatParamTypePrimitive(self): | |
| 85 self.assertEqual('int32_t', self.generator.FormatParamType( | |
| 86 self.namespace.types['MyType1'].properties['int_single'])) | |
| 87 self.assertEqual('PP_Int32_Array', self.generator.FormatParamType( | |
| 88 self.namespace.types['MyType1'].properties['int_array'])) | |
| 89 self.assertEqual('PP_Optional_Int32', self.generator.FormatParamType( | |
| 90 self.namespace.types['MyType1'].properties['optional_int'])) | |
| 91 self.assertEqual('PP_Optional_Int32_Array', self.generator.FormatParamType( | |
| 92 self.namespace.types['MyType1'].properties['optional_int_array'])) | |
| 93 self.assertEqual('double_t', self.generator.FormatParamType( | |
| 94 self.namespace.types['MyType1'].properties['double_single'])) | |
| 95 self.assertEqual('PP_Double_Array', self.generator.FormatParamType( | |
| 96 self.namespace.types['MyType1'].properties['double_array'])) | |
| 97 self.assertEqual('PP_Optional_Double', self.generator.FormatParamType( | |
| 98 self.namespace.types['MyType1'].properties['optional_double'])) | |
| 99 self.assertEqual('PP_Optional_Double_Array', self.generator.FormatParamType( | |
| 100 self.namespace.types['MyType1'].properties['optional_double_array'])) | |
| 101 self.assertEqual('PP_Var', self.generator.FormatParamType( | |
| 102 self.namespace.types['MyType1'].properties['string'])) | |
| 103 self.assertEqual('PP_String_Array', self.generator.FormatParamType( | |
| 104 self.namespace.types['MyType1'].properties['string_array'])) | |
| 105 self.assertEqual('PP_Var', self.generator.FormatParamType( | |
| 106 self.namespace.types['MyType1'].properties['optional_string'])) | |
| 107 self.assertEqual('PP_Optional_String_Array', self.generator.FormatParamType( | |
| 108 self.namespace.types['MyType1'].properties['optional_string_array'])) | |
| 109 | |
| 110 def testFormatParamTypeStruct(self): | |
| 111 self.assertEqual('PP_Idl_pepper_MyType0', self.generator.FormatParamType( | |
| 112 self.namespace.types['MyType1'].properties['struct_single'])) | |
| 113 self.assertEqual( | |
| 114 'PP_Idl_pepper_MyType0_Array', self.generator.FormatParamType( | |
| 115 self.namespace.types['MyType1'].properties['struct_array'])) | |
| 116 self.assertEqual( | |
| 117 'PP_Optional_Idl_pepper_MyType0', self.generator.FormatParamType( | |
| 118 self.namespace.types['MyType1'].properties['optional_struct'])) | |
| 119 self.assertEqual( | |
| 120 'PP_Optional_Idl_pepper_MyType0_Array', self.generator.FormatParamType( | |
| 121 self.namespace.types['MyType1'].properties[ | |
| 122 'optional_struct_array'])) | |
| 123 | |
| 124 self.assertEqual( | |
| 125 'PP_Idl_pepper_MyType0_Dev', self.dev_generator.FormatParamType( | |
| 126 self.namespace.types['MyType1'].properties['struct_single'])) | |
| 127 self.assertEqual( | |
| 128 'PP_Idl_pepper_MyType0_Array_Dev', self.dev_generator.FormatParamType( | |
| 129 self.namespace.types['MyType1'].properties['struct_array'])) | |
| 130 self.assertEqual( | |
| 131 'PP_Optional_Idl_pepper_MyType0_Dev', | |
| 132 self.dev_generator.FormatParamType( | |
| 133 self.namespace.types['MyType1'].properties['optional_struct'])) | |
| 134 self.assertEqual( | |
| 135 'PP_Optional_Idl_pepper_MyType0_Array_Dev', | |
| 136 self.dev_generator.FormatParamType( | |
| 137 self.namespace.types['MyType1'].properties[ | |
| 138 'optional_struct_array'])) | |
| 139 | |
| 140 def testFormatParamTypeEnum(self): | |
| 141 self.assertEqual('PP_Idl_pepper_EnumType', self.generator.FormatParamType( | |
| 142 self.namespace.types['MyType1'].properties['enum_single'])) | |
| 143 self.assertEqual( | |
| 144 'PP_Idl_pepper_EnumType_Array', self.generator.FormatParamType( | |
| 145 self.namespace.types['MyType1'].properties['enum_array'])) | |
| 146 self.assertEqual( | |
| 147 'PP_Optional_Idl_pepper_EnumType', self.generator.FormatParamType( | |
| 148 self.namespace.types['MyType1'].properties['optional_enum'])) | |
| 149 self.assertEqual( | |
| 150 'PP_Optional_Idl_pepper_EnumType_Array', self.generator.FormatParamType( | |
| 151 self.namespace.types['MyType1'].properties['optional_enum_array'])) | |
| 152 | |
| 153 self.assertEqual( | |
| 154 'PP_Idl_pepper_EnumType_Dev', self.dev_generator.FormatParamType( | |
| 155 self.namespace.types['MyType1'].properties['enum_single'])) | |
| 156 self.assertEqual( | |
| 157 'PP_Idl_pepper_EnumType_Array_Dev', self.dev_generator.FormatParamType( | |
| 158 self.namespace.types['MyType1'].properties['enum_array'])) | |
| 159 self.assertEqual( | |
| 160 'PP_Optional_Idl_pepper_EnumType_Dev', | |
| 161 self.dev_generator.FormatParamType( | |
| 162 self.namespace.types['MyType1'].properties['optional_enum'])) | |
| 163 self.assertEqual( | |
| 164 'PP_Optional_Idl_pepper_EnumType_Array_Dev', | |
| 165 self.dev_generator.FormatParamType( | |
| 166 self.namespace.types['MyType1'].properties['optional_enum_array'])) | |
| 167 | |
| 168 def testEnumValueName(self): | |
| 169 enum_type = self.namespace.types['EnumType'] | |
| 170 self.assertEqual('PP_IDL_PEPPER_ENUMTYPE_NAME1', | |
| 171 self.generator.EnumValueName(enum_type.enum_values[0], | |
| 172 enum_type)) | |
| 173 self.assertEqual('PP_IDL_PEPPER_ENUMTYPE_NAME2', | |
| 174 self.generator.EnumValueName(enum_type.enum_values[1], | |
| 175 enum_type)) | |
| 176 enum_type = self.namespace.types['AnotherEnumType'] | |
| 177 self.assertEqual('PP_IDL_PEPPER_ANOTHERENUMTYPE_NAME1', | |
| 178 self.generator.EnumValueName(enum_type.enum_values[0], | |
| 179 enum_type)) | |
| 180 self.assertEqual('PP_IDL_PEPPER_ANOTHERENUMTYPE_NAME2', | |
| 181 self.generator.EnumValueName(enum_type.enum_values[1], | |
| 182 enum_type)) | |
| 183 | |
| 184 def testReturnsTypes(self): | |
| 185 self.assertEqual('void', self.generator.GetFunctionReturnType( | |
| 186 self.namespace.functions['function1'])) | |
| 187 self.assertEqual('void', self.generator.GetFunctionReturnType( | |
| 188 self.namespace.functions['function2'])) | |
| 189 self.assertEqual('int32_t', self.generator.GetFunctionReturnType( | |
| 190 self.namespace.functions['function3'])) | |
| 191 self.assertEqual('int32_t', self.generator.GetFunctionReturnType( | |
| 192 self.namespace.functions['function4'])) | |
| 193 self.assertEqual('int32_t', self.generator.GetFunctionReturnType( | |
| 194 self.namespace.functions['function5'])) | |
| 195 self.assertEqual('int32_t', self.generator.GetFunctionReturnType( | |
| 196 self.namespace.functions['function6'])) | |
| 197 | |
| 198 def testDevSuffix(self): | |
| 199 self.assertEqual('Foo_Dev', self.dev_generator.AddDevSuffix('Foo')) | |
| 200 self.assertEqual('Foo', self.generator.AddDevSuffix('Foo')) | |
| 201 | |
| 202 if __name__ == '__main__': | |
| 203 unittest.main() | |
| OLD | NEW |
