Code generation for extensions api

tools/json_schema_compiler/type_manager_test.py

Index: tools/json_schema_compiler/type_manager_test.py
diff --git a/tools/json_schema_compiler/type_manager_test.py b/tools/json_schema_compiler/type_manager_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..5656f8921aa4e8fa1c014c440be466d6cdd973ea
--- /dev/null
+++ b/tools/json_schema_compiler/type_manager_test.py
@@ -0,0 +1,135 @@
+import unittest
+import model
+import code
+import json
+import type_manager
+
+class TestTypeManager(unittest.TestCase):
+  def setUp(self):
+    self.model = model.Model()
+    self.permissions_json = json.loads(open('test/permissions.json').read())
+    self.model.add_namespace(self.permissions_json[0], 'extensions',
+        'path/to/permissions.json', '_api')
+    self.permissions = self.model.namespaces.get('permissions')
+    self.windows_json = json.loads(open('test/windows.json').read())
+    self.model.add_namespace(self.windows_json[0], 'extensions',
+        'path/to/window.json', '_api')
+    self.windows = self.model.namespaces.get('windows')
+    self.tabs_json = json.loads(open('test/tabs.json').read())
+    self.model.add_namespace(self.tabs_json[0], 'extensions',
+        'path/to/tabs.json', '_api')
+    self.tabs = self.model.namespaces.get('tabs')
+
+  def test_resolve_generated_includes(self):
+    manager = type_manager.TypeManager(self.windows, self.model)
+    self.assertEquals(manager.resolve_generated_includes().code,
+        ['#include "path/to/tabs_api.h"'])
+    manager = type_manager.TypeManager(self.permissions, self.model)
+    self.assertEquals(manager.resolve_generated_includes().code,
+        [])
+
+  def test_get_type_simple(self):
+    manager = type_manager.TypeManager(self.tabs, self.model)
+    self.assertEquals(manager.get_type(
+        self.tabs.types['Tab'].properties['id']),
+        'int')
+    self.assertEquals(manager.get_type(
+        self.tabs.types['Tab'].properties['status']),
+        'std::string')
+    self.assertEquals(manager.get_type(
+        self.tabs.types['Tab'].properties['selected']),
+        'bool')
+
+  def test_get_type_array(self):
+    manager = type_manager.TypeManager(self.windows, self.model)
+    self.assertEquals(manager.get_type(
+        self.windows.functions['getAll'].callback.param),
+        'std::vector<Window>')
+    manager = type_manager.TypeManager(self.permissions, self.model)
+    self.assertEquals(manager.get_type(
+        self.permissions.types['Permissions'].properties['origins']),
+        'std::vector<std::string>')
+
+  def test_get_type_local_ref(self):
+    manager = type_manager.TypeManager(self.tabs, self.model)
+    self.assertEquals(manager.get_type(
+        self.tabs.functions['get'].callback.param),
+        'Tab')
+
+  def test_get_type_included_ref(self):
+    manager = type_manager.TypeManager(self.windows, self.model)
+    self.assertEquals(manager.get_type(
+        self.windows.types['Window'].properties['tabs']),
+        'std::vector<tabs_api::Tab>')
+
+  def test_get_type_notfound(self):
+    prop = self.windows.types['Window'].properties['tabs'].item_type
+    prop.json_type = 'Something'
+    manager = type_manager.TypeManager(self.windows, self.model)
+    self.assertRaises(KeyError, manager.get_type, prop)
+
+  def test_get_type_notimplemented(self):
+    prop = self.windows.types['Window'].properties['tabs'].item_type
+    prop.type = 10
+    manager = type_manager.TypeManager(self.windows, self.model)
+    self.assertRaises(NotImplementedError, manager.get_type, prop)
+
+  def test_get_generic_type(self):
+    manager = type_manager.TypeManager(self.permissions, self.model)
+    self.assertEquals(manager.get_generic_type(
+        self.permissions.types['Permissions'].properties['origins']),
+        'std::vector<std::string> ')
+    self.assertEquals(manager.get_generic_type(
+        self.permissions.functions['contains'].callback.param),
+        'bool')
+
+  def test_parameter_declaration(self):
+    manager = type_manager.TypeManager(self.tabs, self.model)
+    self.assertEquals(manager.parameter_declaration(
+        self.tabs.functions['query'].callback.param),
+        "std::vector<Tab> result")
+    modifiers = {model.PropertyType.REF: type_manager.ParamFormat.POINTER,
+        model.PropertyType.OBJECT: type_manager.ParamFormat.REFERENCE,
+        model.PropertyType.ARRAY: '%(name)s %(type)s'}
+    self.assertEquals(manager.parameter_declaration(
+        self.tabs.functions['update'].callback.param,
+        type_modifiers=modifiers),
+        "Tab* tab")
+    self.assertEquals(manager.parameter_declaration(
+        self.tabs.functions['update'].params[1],
+        type_modifiers=modifiers),
+        "UpdateProperties& updateProperties")
+    self.assertEquals(manager.parameter_declaration(
+        self.tabs.functions['query'].callback.param,
+        type_modifiers=modifiers),
+        "result std::vector<Tab>")
+
+  def test_comment(self):
+    long_comment = ('This comment is eighty nine characters in longness, '
+        'that is, to use another word, length')
+    c = code.Code()
+    c.comment(long_comment)
+    self.assertEquals(c.render(),
+        '// This comment is eighty nine characters in longness, that is, to use another\n'
+        '// word, length')
+    c = code.Code()
+    c.sblock('sblock')
+    c.comment(long_comment)
+    c.eblock('eblock')
+    c.comment(long_comment)
+    self.assertEquals(c.render(),
+        'sblock\n'
+        '  // This comment is eighty nine characters in longness, that is, to use\n'
+        '  // another word, length\n'
+        'eblock\n'
+        '// This comment is eighty nine characters in longness, that is, to use another\n'
+        '// word, length')
+    long_word = 'x' * 100
+    c = code.Code()
+    c.comment(long_word)
+    self.assertEquals(c.render(),
+        '// ' + 'x' * 77 + '\n'
+        '// ' + 'x' * 23)
+
+if __name__ == '__main__':
+  unittest.main()