src/tools/json_schema_compiler/cpp_type_generator_test.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 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 from cpp_type_generator import CppTypeGenerator
   7 from json_schema import CachedLoad
   8 import model
   9 import unittest
  10
  11 from collections import defaultdict
  12
  13 class _FakeSchemaLoader(object):
  14   def __init__(self, model):
  15     self._model = model
  16
  17   def ResolveType(self, type_name, default):
  18     parts = type_name.rsplit('.', 1)
  19     if len(parts) == 1:
  20       return default if type_name in default.types else None
  21     return self._model.namespaces[parts[0]]
  22
  23 class CppTypeGeneratorTest(unittest.TestCase):
  24   def setUp(self):
  25     self.models = defaultdict(model.Model)
  26
  27     self.forbidden_json = CachedLoad('test/forbidden.json')
  28     self.forbidden = self.models['forbidden'].AddNamespace(
  29         self.forbidden_json[0], 'path/to/forbidden.json')
  30     self.permissions_json = CachedLoad('test/permissions.json')
  31     self.permissions = self.models['permissions'].AddNamespace(
  32         self.permissions_json[0], 'path/to/permissions.json')
  33     self.windows_json = CachedLoad('test/windows.json')
  34     self.windows = self.models['windows'].AddNamespace(self.windows_json[0],
  35                                                        'path/to/window.json')
  36     self.tabs_json = CachedLoad('test/tabs.json')
  37     self.tabs = self.models['tabs'].AddNamespace(self.tabs_json[0],
  38                                                  'path/to/tabs.json')
  39     self.browser_action_json = CachedLoad('test/browser_action.json')
  40     self.browser_action = self.models['browser_action'].AddNamespace(
  41         self.browser_action_json[0], 'path/to/browser_action.json')
  42     self.font_settings_json = CachedLoad('test/font_settings.json')
  43     self.font_settings = self.models['font_settings'].AddNamespace(
  44         self.font_settings_json[0], 'path/to/font_settings.json')
  45     self.dependency_tester_json = CachedLoad('test/dependency_tester.json')
  46     self.dependency_tester = self.models['dependency_tester'].AddNamespace(
  47         self.dependency_tester_json[0], 'path/to/dependency_tester.json')
  48     self.content_settings_json = CachedLoad('test/content_settings.json')
  49     self.content_settings = self.models['content_settings'].AddNamespace(
  50         self.content_settings_json[0], 'path/to/content_settings.json')
  51
  52   def testGenerateIncludesAndForwardDeclarations(self):
  53     m = model.Model()
  54     m.AddNamespace(self.windows_json[0], 'path/to/windows.json')
  55     m.AddNamespace(self.tabs_json[0], 'path/to/tabs.json')
  56     manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
  57
  58     self.assertEquals('', manager.GenerateIncludes().Render())
  59     self.assertEquals('#include "path/to/tabs.h"',
  60                       manager.GenerateIncludes(include_soft=True).Render())
  61     self.assertEquals('namespace tabs {\n'
  62                       'struct Tab;\n'
  63                       '}',
  64                       manager.GenerateForwardDeclarations().Render())
  65     manager = CppTypeGenerator(self.models.get('permissions'),
  66                                _FakeSchemaLoader(m))
  67     self.assertEquals('', manager.GenerateIncludes().Render())
  68     self.assertEquals('', manager.GenerateIncludes().Render())
  69     self.assertEquals('', manager.GenerateForwardDeclarations().Render())
  70     manager = CppTypeGenerator(self.models.get('content_settings'),
  71                                _FakeSchemaLoader(m))
  72     self.assertEquals('', manager.GenerateIncludes().Render())
  73
  74   def testGenerateIncludesAndForwardDeclarationsDependencies(self):
  75     m = model.Model()
  76     # Insert 'font_settings' before 'browser_action' in order to test that
  77     # CppTypeGenerator sorts them properly.
  78     m.AddNamespace(self.font_settings_json[0], 'path/to/font_settings.json')
  79     m.AddNamespace(self.browser_action_json[0], 'path/to/browser_action.json')
  80     dependency_tester = m.AddNamespace(self.dependency_tester_json[0],
  81                                        'path/to/dependency_tester.json')
  82     manager = CppTypeGenerator(m,
  83                                _FakeSchemaLoader(m),
  84                                default_namespace=dependency_tester)
  85     self.assertEquals('#include "path/to/browser_action.h"\n'
  86                       '#include "path/to/font_settings.h"',
  87                       manager.GenerateIncludes().Render())
  88     self.assertEquals('namespace browser_action {\n'
  89                       '}\n'
  90                       'namespace font_settings {\n'
  91                       '}',
  92                       manager.GenerateForwardDeclarations().Render())
  93
  94   def testGetCppTypeSimple(self):
  95     manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
  96     self.assertEquals(
  97         'int',
  98         manager.GetCppType(self.tabs.types['Tab'].properties['id'].type_))
  99     self.assertEquals(
 100         'std::string',
 101         manager.GetCppType(self.tabs.types['Tab'].properties['status'].type_))
 102     self.assertEquals(
 103         'bool',
 104         manager.GetCppType(self.tabs.types['Tab'].properties['selected'].type_))
 105
 106   def testStringAsType(self):
 107     manager = CppTypeGenerator(self.models.get('font_settings'),
 108                                _FakeSchemaLoader(None))
 109     self.assertEquals(
 110         'std::string',
 111         manager.GetCppType(self.font_settings.types['FakeStringType']))
 112
 113   def testArrayAsType(self):
 114     manager = CppTypeGenerator(self.models.get('browser_action'),
 115                                _FakeSchemaLoader(None))
 116     self.assertEquals(
 117         'std::vector<int>',
 118         manager.GetCppType(self.browser_action.types['ColorArray']))
 119
 120   def testGetCppTypeArray(self):
 121     manager = CppTypeGenerator(self.models.get('windows'),
 122                                 _FakeSchemaLoader(None))
 123     self.assertEquals(
 124         'std::vector<linked_ptr<Window> >',
 125         manager.GetCppType(
 126             self.windows.functions['getAll'].callback.params[0].type_))
 127     manager = CppTypeGenerator(self.models.get('permissions'),
 128                                _FakeSchemaLoader(None))
 129     self.assertEquals(
 130         'std::vector<std::string>',
 131         manager.GetCppType(
 132             self.permissions.types['Permissions'].properties['origins'].type_))
 133
 134   def testGetCppTypeLocalRef(self):
 135     manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
 136     self.assertEquals(
 137         'Tab',
 138         manager.GetCppType(self.tabs.functions['get'].callback.params[0].type_))
 139
 140   def testGetCppTypeIncludedRef(self):
 141     m = model.Model()
 142     m.AddNamespace(self.windows_json[0], 'path/to/windows.json')
 143     m.AddNamespace(self.tabs_json[0], 'path/to/tabs.json')
 144     manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
 145     self.assertEquals(
 146         'std::vector<linked_ptr<tabs::Tab> >',
 147         manager.GetCppType(
 148             self.windows.types['Window'].properties['tabs'].type_))
 149
 150   def testGetCppTypeWithPadForGeneric(self):
 151     manager = CppTypeGenerator(self.models.get('permissions'),
 152                                _FakeSchemaLoader(None))
 153     self.assertEquals('std::vector<std::string>',
 154         manager.GetCppType(
 155             self.permissions.types['Permissions'].properties['origins'].type_,
 156             is_in_container=False))
 157     self.assertEquals('linked_ptr<std::vector<std::string> >',
 158         manager.GetCppType(
 159             self.permissions.types['Permissions'].properties['origins'].type_,
 160             is_in_container=True))
 161     self.assertEquals('bool',
 162         manager.GetCppType(
 163             self.permissions.functions['contains'].callback.params[0].type_,
 164         is_in_container=True))
 165
 166 if __name__ == '__main__':
 167   unittest.main()