Code generation for extensions api

tools/json_schema_compiler/code_test.py

Index: tools/json_schema_compiler/code_test.py
diff --git a/tools/json_schema_compiler/code_test.py b/tools/json_schema_compiler/code_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..99ce057c6bb4b8e676da82867d3514fa72350b60
--- /dev/null
+++ b/tools/json_schema_compiler/code_test.py
@@ -0,0 +1,241 @@
+# Copyright (c) 2011 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 unittest
+import model
+import code
+import json
+
+class TestTypeManager(unittest.TestCase):
+  def setUp(self):
+    self.model = model.ModelT()
+    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):
+    type_manager = code.TypeManager(self.windows, self.model)
+    self.assertEquals(type_manager.resolve_generated_includes().code,
+        ['#include "path/to/tabs_api.h"'])
+    type_manager = code.TypeManager(self.permissions, self.model)
+    self.assertEquals(type_manager.resolve_generated_includes().code,
+        [])
+
+  def test_get_type_simple(self):
+    type_manager = code.TypeManager(self.tabs, self.model)
+    self.assertEquals(type_manager.get_type(
+        self.tabs.types['Tab'].properties['id']),
+        'int')
+    self.assertEquals(type_manager.get_type(
+        self.tabs.types['Tab'].properties['status']),
+        'std::string')
+    self.assertEquals(type_manager.get_type(
+        self.tabs.types['Tab'].properties['selected']),
+        'bool')
+
+  def test_get_type_array(self):
+    type_manager = code.TypeManager(self.windows, self.model)
+    self.assertEquals(type_manager.get_type(
+        self.windows.functions['getAll'].callback.param),
+        'std::vector<Window>')
+    type_manager = code.TypeManager(self.permissions, self.model)
+    self.assertEquals(type_manager.get_type(
+        self.permissions.types['Permissions'].properties['origins']),
+        'std::vector<std::string>')
+
+  def test_get_type_local_ref(self):
+    type_manager = code.TypeManager(self.tabs, self.model)
+    self.assertEquals(type_manager.get_type(
+        self.tabs.functions['get'].callback.param),
+        'Tab')
+
+  def test_get_type_included_ref(self):
+    type_manager = code.TypeManager(self.windows, self.model)
+    self.assertEquals(type_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'
+    type_manager = code.TypeManager(self.windows, self.model)
+    self.assertRaises(KeyError, type_manager.get_type, prop)
+
+  def test_get_type_notimplemented(self):
+    prop = self.windows.types['Window'].properties['tabs'].item_type
+    prop.type = 10
+    type_manager = code.TypeManager(self.windows, self.model)
+    self.assertRaises(NotImplementedError, type_manager.get_type, prop)
+
+  def test_get_generic_type(self):
+    type_manager = code.TypeManager(self.permissions, self.model)
+    self.assertEquals(type_manager.get_generic_type(
+        self.permissions.types['Permissions'].properties['origins']),
+        'std::vector<std::string> ')
+    self.assertEquals(type_manager.get_generic_type(
+        self.permissions.functions['contains'].callback.param),
+        'bool')
+
+  def test_parameter_declaration(self):
+    type_manager = code.TypeManager(self.tabs, self.model)
+    self.assertEquals(type_manager.parameter_declaration(
+        self.tabs.functions['query'].callback.param),
+        "std::vector<Tab> result")
+    modifiers = {model.PropertyType.REF: code.ParamFormat.POINTER,
+        model.PropertyType.OBJECT: code.ParamFormat.REFERENCE,
+        model.PropertyType.ARRAY: '%(name)s %(type)s'}
+    self.assertEquals(type_manager.parameter_declaration(
+        self.tabs.functions['update'].callback.param,
+        type_modifiers=modifiers),
+        "Tab* tab")
+    self.assertEquals(type_manager.parameter_declaration(
+        self.tabs.functions['update'].params[1],
+        type_modifiers=modifiers),
+        "UpdateProperties& updateProperties")
+    self.assertEquals(type_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.to_string(),
+        '// 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.to_string(),
+        '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.to_string(),
+        '// ' + 'x' * 77 + '\n'
+        '// ' + 'x' * 23)
+
+class TestCppName(unittest.TestCase):
+  def test_cpp_name(self):
+    self.assertEquals(code.cpp_name('permissions'), 'Permissions')
+    self.assertEquals(code.cpp_name('updateAllTheThings'), 'UpdateAllTheThings')
+    self.assertEquals(code.cpp_name('aa.bb.cc'), 'Aa_Bb_Cc')
+
+class TestCode(unittest.TestCase):
+  def test_append(self):
+    c = code.Code()
+    c.append('line')
+    self.assertEquals(c.to_string(), 'line')
+
+  def test_block(self):
+    c = code.Code()
+    c.append('line')
+    c.sblock('sblock')
+    c.append('inner')
+    c.append('moreinner')
+    c.sblock('moresblock')
+    c.append('inner')
+    c.eblock('out')
+    c.append('inner')
+    c.eblock('out')
+    self.assertEquals(c.to_string(),
+      'line\n'
+      'sblock\n'
+      '  inner\n'
+      '  moreinner\n'
+      '  moresblock\n'
+      '    inner\n'
+      '  out\n'
+      '  inner\n'
+      'out')
+
+  def test_add(self):
+    b = code.Code()
+    b.sblock('2')
+    b.append('2')
+    b.eblock('2')
+    c = code.Code()
+    c.sblock('1')
+    c.add(b)
+    c.append('1')
+    c.eblock('1')
+    self.assertEquals(c.to_string(),
+      '1\n'
+      '  2\n'
+      '    2\n'
+      '  2\n'
+      '  1\n'
+      '1')
+    d = code.Code()
+    a = code.Code()
+    a.add(d)
+    self.assertEquals(a.to_string(), '')
+    a.add(c)
+    self.assertEquals(a.to_string(),
+      '1\n'
+      '  2\n'
+      '    2\n'
+      '  2\n'
+      '  1\n'
+      '1')
+
+  def test_add_errors(self):
+    c = code.Code()
+    d = code.Code()
+    d.append('%s')
+    self.assertRaises(TypeError, c.add, d)
+    d = code.Code()
+    d.append('%(classname)s')
+    self.assertRaises(TypeError, c.add, d)
+    d = 'line of code'
+    self.assertRaises(TypeError, c.add, d)
+
+  def test_substitute(self):
+    c = code.Code()
+    c.append('%(var1)s %(var2)s %(var1)s')
+    c.substitute({'var1': 'one', 'var2': 'two'})
+    self.assertEquals(c.to_string(), 'one two one')
+    c.append('%(var1)s %(var2)s %(var3)s')
+    c.append('%(var1)s %(var2)s %(var3)s')
+    c.substitute({'var1': 'one', 'var2': 'two', 'var3': 'three'})
+    self.assertEquals(c.to_string(),
+        'one two one\n'
+        'one two three\n'
+        'one two three')
+
+  def test_substitute_errors(self):
+    # No unnamed placeholders allowed when substitute is run
+    c = code.Code()
+    c.append('%s %s')
+    self.assertRaises(TypeError, c.substitute, ('var1', 'one'))
+    c = code.Code()
+    c.append('%s %(var1)s')
+    self.assertRaises(TypeError, c.substitute, {'var1': 'one'})
+    c = code.Code()
+    c.append('%s %(var1)s')
+    self.assertRaises(TypeError, c.substitute, {'var1': 'one'})
+    c = code.Code()
+    c.append('%(var1)s')
+    self.assertRaises(KeyError, c.substitute, {'clearlynotvar1': 'one'})
+
+if __name__ == '__main__':
+  unittest.main()