Support scoped types in PPAPI IDL.

tools/json_schema_compiler/idl_schema_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 idl_schema
 import unittest
 
 from json_parse import OrderedDict
 
@@ skipping 23 matching lines @@
 class IdlSchemaTest(unittest.TestCase):
   def setUp(self):
     loaded = idl_schema.Load('test/idl_basics.idl')
     self.assertEquals(1, len(loaded))
     self.assertEquals('idl_basics', loaded[0]['namespace'])
     self.idl_basics = loaded[0]
     self.maxDiff = None
 
   def testSimpleCallbacks(self):
     schema = self.idl_basics
-    expected = [{'type':'function', 'name':'cb', 'parameters':[]}]
+    expected = [{'type': 'function', 'name': 'cb', 'parameters':[]}]
     self.assertEquals(expected, getParams(schema, 'function4'))
 
-    expected = [{'type':'function', 'name':'cb',
-                 'parameters':[{'name':'x', 'type':'integer'}]}]
+    expected = [{'type': 'function', 'name': 'cb',
+                 'parameters':[{'name': 'x', 'type': 'integer'}]}]
     self.assertEquals(expected, getParams(schema, 'function5'))
 
-    expected = [{'type':'function', 'name':'cb',
-                 'parameters':[{'name':'arg', '$ref':'MyType1'}]}]
+    expected = [{'type': 'function', 'name': 'cb',
+                 'parameters':[{'name': 'arg', '$ref': 'MyType1'}]}]
     self.assertEquals(expected, getParams(schema, 'function6'))
 
   def testCallbackWithArrayArgument(self):
     schema = self.idl_basics
-    expected = [{'type':'function', 'name':'cb',
-                 'parameters':[{'name':'arg', 'type':'array',
-                                'items':{'$ref':'MyType2'}}]}]
+    expected = [{'type': 'function', 'name': 'cb',
+                 'parameters':[{'name': 'arg', 'type': 'array',
+                                'items':{'$ref': 'MyType2'}}]}]
     self.assertEquals(expected, getParams(schema, 'function12'))
 
 
   def testArrayOfCallbacks(self):
     schema = idl_schema.Load('test/idl_function_types.idl')[0]
-    expected = [{'type':'array', 'name':'callbacks',
-                 'items':{'type':'function', 'name':'MyCallback',
-                          'parameters':[{'type':'integer', 'name':'x'}]}}]
+    expected = [{'type': 'array', 'name': 'callbacks',
+                 'items':{'type': 'function', 'name': 'MyCallback',
+                          'parameters':[{'type': 'integer', 'name': 'x'}]}}]
     self.assertEquals(expected, getParams(schema, 'whatever'))
 
   def testLegalValues(self):
     self.assertEquals({
         'x': {'name': 'x', 'type': 'integer', 'enum': [1,2],
               'description': 'This comment tests "double-quotes".'},
         'y': {'name': 'y', 'type': 'string'},
         'z': {'name': 'z', 'type': 'string'},
         'a': {'name': 'a', 'type': 'string'},
         'b': {'name': 'b', 'type': 'string'},
         'c': {'name': 'c', 'type': 'string'}},
       getType(self.idl_basics, 'MyType1')['properties'])
 
   def testMemberOrdering(self):
     self.assertEquals(
         ['x', 'y', 'z', 'a', 'b', 'c'],
         getType(self.idl_basics, 'MyType1')['properties'].keys())
 
   def testEnum(self):
     schema = self.idl_basics
     expected = {'enum': [{'name': 'name1', 'description': 'comment1'},
                          {'name': 'name2'}],
                 'description': 'Enum description',
                 'type': 'string', 'id': 'EnumType'}
     self.assertEquals(expected, getType(schema, expected['id']))
 
-    expected = [{'name':'type', '$ref':'EnumType'},
-                {'type':'function', 'name':'cb',
-                  'parameters':[{'name':'type', '$ref':'EnumType'}]}]
+    expected = [{'name': 'type', '$ref': 'EnumType'},
+                {'type': 'function', 'name': 'cb',
+                  'parameters':[{'name': 'type', '$ref': 'EnumType'}]}]
     self.assertEquals(expected, getParams(schema, 'function13'))
 
     expected = [{'items': {'$ref': 'EnumType'}, 'name': 'types',
                  'type': 'array'}]
     self.assertEquals(expected, getParams(schema, 'function14'))
 
+  def testScopedArguments(self):
+    schema = self.idl_basics
+    expected = [{'name': 'value', '$ref': 'idl_other_namespace.SomeType'}]
+    self.assertEquals(expected, getParams(schema, 'function20'))
+
+    expected = [{'items': {'$ref': 'idl_other_namespace.SomeType'},
+                 'name': 'values',
+                 'type': 'array'}]
+    self.assertEquals(expected, getParams(schema, 'function21'))
+
+    expected = [{'name': 'value',
+                 '$ref': 'idl_other_namespace.sub_namespace.AnotherType'}]
+    self.assertEquals(expected, getParams(schema, 'function22'))
+
+    expected = [{'items': {'$ref': 'idl_other_namespace.sub_namespace.'
+                                   'AnotherType'},
+                 'name': 'values',
+                 'type': 'array'}]
+    self.assertEquals(expected, getParams(schema, 'function23'))
+
   def testNoCompile(self):
     schema = self.idl_basics
     func = getFunction(schema, 'function15')
     self.assertTrue(func is not None)
     self.assertTrue(func['nocompile'])
 
   def testNoDocOnEnum(self):
     schema = self.idl_basics
     enum_with_nodoc = getType(schema, 'EnumTypeWithNoDoc')
     self.assertTrue(enum_with_nodoc is not None)
     self.assertTrue(enum_with_nodoc['nodoc'])
 
   def testInternalNamespace(self):
     idl_basics  = self.idl_basics
     self.assertEquals('idl_basics', idl_basics['namespace'])
     self.assertTrue(idl_basics['internal'])
     self.assertFalse(idl_basics['nodoc'])
 
   def testReturnTypes(self):
     schema = self.idl_basics
-    self.assertEquals({'name': 'function19', 'type': 'integer'},
-                      getReturns(schema, 'function19'))
-    self.assertEquals({'name': 'function20', '$ref': 'MyType1',
+    self.assertEquals({'name': 'function24', 'type': 'integer'},
+                      getReturns(schema, 'function24'))
+    self.assertEquals({'name': 'function25', '$ref': 'MyType1',
                        'optional': True},
-                      getReturns(schema, 'function20'))
-    self.assertEquals({'name': 'function21', 'type': 'array',
+                      getReturns(schema, 'function25'))
+    self.assertEquals({'name': 'function26', 'type': 'array',
                        'items': {'$ref': 'MyType1'}},
-                      getReturns(schema, 'function21'))
-    self.assertEquals({'name': 'function22', '$ref': 'EnumType',
+                      getReturns(schema, 'function26'))
+    self.assertEquals({'name': 'function27', '$ref': 'EnumType',
                        'optional': True},
-                      getReturns(schema, 'function22'))
-    self.assertEquals({'name': 'function23', 'type': 'array',
+                      getReturns(schema, 'function27'))
+    self.assertEquals({'name': 'function28', 'type': 'array',
                        'items': {'$ref': 'EnumType'}},
-                      getReturns(schema, 'function23'))
+                      getReturns(schema, 'function28'))
+    self.assertEquals({'name': 'function29', '$ref':
+                       'idl_other_namespace.SomeType',
+                       'optional': True},
+                      getReturns(schema, 'function29'))
+    self.assertEquals({'name': 'function30', 'type': 'array',
+                       'items': {'$ref': 'idl_other_namespace.SomeType'}},
+                      getReturns(schema, 'function30'))
 
   def testChromeOSPlatformsNamespace(self):
     schema = idl_schema.Load('test/idl_namespace_chromeos.idl')[0]
     self.assertEquals('idl_namespace_chromeos', schema['namespace'])
     expected = ['chromeos']
     self.assertEquals(expected, schema['platforms'])
 
   def testAllPlatformsNamespace(self):
     schema = idl_schema.Load('test/idl_namespace_all_platforms.idl')[0]
     self.assertEquals('idl_namespace_all_platforms', schema['namespace'])
@@ skipping 212 matching lines @@
                      {'type': 'string'}
                    ]
                  }]
                }]
 
     self.assertEquals(expected, badabish_params)
 
 
 if __name__ == '__main__':
   unittest.main()