#!/usr/bin/env python3
# Copyright 2012 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from cpp_namespace_environment import CppNamespaceEnvironment
from cpp_type_generator import CppTypeGenerator
from json_schema import CachedLoad
import idl_schema
import model
import unittest
from collections import defaultdict
class _FakeSchemaLoader(object):
def __init__(self, model):
self._model = model
def ResolveType(self, type_name, default):
parts = type_name.rsplit('.', 1)
if len(parts) == 1:
return default if type_name in default.types else None
return self._model.namespaces[parts[0]]
class CppTypeGeneratorTest(unittest.TestCase):
def setUp(self):
self.models = defaultdict(model.Model)
forbidden_json = CachedLoad('test/forbidden.json')
self.models['forbidden'].AddNamespace(forbidden_json[0],
'path/to/forbidden.json')
permissions_json = CachedLoad('test/permissions.json')
self.permissions = self.models['permissions'].AddNamespace(
permissions_json[0], 'path/to/permissions.json')
self.windows_json = CachedLoad('test/windows.json')
self.windows = self.models['windows'].AddNamespace(self.windows_json[0],
'path/to/window.json')
self.tabs_json = CachedLoad('test/tabs.json')
self.tabs = self.models['tabs'].AddNamespace(self.tabs_json[0],
'path/to/tabs.json')
self.browser_action_json = CachedLoad('test/browser_action.json')
self.browser_action = self.models['browser_action'].AddNamespace(
self.browser_action_json[0], 'path/to/browser_action.json')
self.font_settings_json = CachedLoad('test/font_settings.json')
self.font_settings = self.models['font_settings'].AddNamespace(
self.font_settings_json[0], 'path/to/font_settings.json')
self.dependency_tester_json = CachedLoad('test/dependency_tester.json')
self.models['dependency_tester'].AddNamespace(
self.dependency_tester_json[0], 'path/to/dependency_tester.json')
content_settings_json = CachedLoad('test/content_settings.json')
self.models['content_settings'].AddNamespace(
content_settings_json[0], 'path/to/content_settings.json')
objects_movable_idl = idl_schema.Load('test/objects_movable.idl')
self.objects_movable = self.models['objects_movable'].AddNamespace(
objects_movable_idl[0],
'path/to/objects_movable.idl',
include_compiler_options=True)
self.simple_api_json = CachedLoad('test/simple_api.json')
self.models['simple_api'].AddNamespace(self.simple_api_json[0],
'path/to/simple_api.json')
self.crossref_enums_json = CachedLoad('test/crossref_enums.json')
self.crossref_enums = self.models['crossref_enums'].AddNamespace(
self.crossref_enums_json[0], 'path/to/crossref_enums.json')
self.crossref_enums_array_json = CachedLoad(
'test/crossref_enums_array.json')
self.models['crossref_enums_array'].AddNamespace(
self.crossref_enums_array_json[0], 'path/to/crossref_enums_array.json')
def testGenerateIncludesAndForwardDeclarations(self):
m = model.Model()
m.AddNamespace(self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEqual('', manager.GenerateIncludes().Render())
self.assertEqual('#include "path/to/tabs.h"',
manager.GenerateIncludes(include_soft=True).Render())
self.assertEqual(
'namespace tabs {\n'
'struct Tab;\n'
'} // namespace tabs',
manager.GenerateForwardDeclarations().Render())
m = model.Model()
m.AddNamespace(
self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('foo::bar::%(namespace)s'))
m.AddNamespace(
self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('foo::bar::%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEqual(
'namespace foo {\n'
'namespace bar {\n'
'namespace tabs {\n'
'struct Tab;\n'
'} // namespace tabs\n'
'} // namespace bar\n'
'} // namespace foo',
manager.GenerateForwardDeclarations().Render())
manager = CppTypeGenerator(self.models.get('permissions'),
_FakeSchemaLoader(m))
self.assertEqual('', manager.GenerateIncludes().Render())
self.assertEqual('', manager.GenerateIncludes().Render())
self.assertEqual('', manager.GenerateForwardDeclarations().Render())
manager = CppTypeGenerator(self.models.get('content_settings'),
_FakeSchemaLoader(m))
self.assertEqual('', manager.GenerateIncludes().Render())
def testGenerateIncludesAndForwardDeclarationsDependencies(self):
m = model.Model()
# Insert 'font_settings' before 'browser_action' in order to test that
# CppTypeGenerator sorts them properly.
m.AddNamespace(self.font_settings_json[0], 'path/to/font_settings.json')
m.AddNamespace(self.browser_action_json[0], 'path/to/browser_action.json')
dependency_tester = m.AddNamespace(self.dependency_tester_json[0],
'path/to/dependency_tester.json')
manager = CppTypeGenerator(m,
_FakeSchemaLoader(m),
default_namespace=dependency_tester)
self.assertEqual(
'#include "path/to/browser_action.h"\n'
'#include "path/to/font_settings.h"',
manager.GenerateIncludes().Render())
self.assertEqual('', manager.GenerateForwardDeclarations().Render())
def testGetCppTypeSimple(self):
manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
self.assertEqual(
'int',
manager.GetCppType(self.tabs.types['Tab'].properties['id'].type_))
self.assertEqual(
'std::string',
manager.GetCppType(self.tabs.types['Tab'].properties['status'].type_))
self.assertEqual(
'bool',
manager.GetCppType(self.tabs.types['Tab'].properties['selected'].type_))
def testStringAsType(self):
manager = CppTypeGenerator(self.models.get('font_settings'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::string',
manager.GetCppType(self.font_settings.types['FakeStringType']))
def testArrayAsType(self):
manager = CppTypeGenerator(self.models.get('browser_action'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::vector<int>',
manager.GetCppType(self.browser_action.types['ColorArray']))
def testGetCppTypeArray(self):
manager = CppTypeGenerator(self.models.get('windows'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::vector<Window>',
manager.GetCppType(
self.windows.functions['getAll'].returns_async.params[0].type_))
manager = CppTypeGenerator(self.models.get('permissions'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::vector<std::string>',
manager.GetCppType(
self.permissions.types['Permissions'].properties['origins'].type_))
manager = CppTypeGenerator(self.models.get('objects_movable'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::vector<MovablePod>',
manager.GetCppType(self.objects_movable.types['MovableParent'].
properties['pods'].type_))
def testGetCppTypeLocalRef(self):
manager = CppTypeGenerator(self.models.get('tabs'), _FakeSchemaLoader(None))
self.assertEqual(
'Tab',
manager.GetCppType(
self.tabs.functions['get'].returns_async.params[0].type_))
def testGetCppTypeIncludedRef(self):
m = model.Model()
m.AddNamespace(self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEqual(
'std::vector<tabs::Tab>',
manager.GetCppType(
self.windows.types['Window'].properties['tabs'].type_))
def testGetCppTypeWithPadForGeneric(self):
manager = CppTypeGenerator(self.models.get('permissions'),
_FakeSchemaLoader(None))
self.assertEqual(
'std::vector<std::string>',
manager.GetCppType(
self.permissions.types['Permissions'].properties['origins'].type_))
self.assertEqual(
'bool',
manager.GetCppType(self.permissions.functions['contains'].returns_async.
params[0].type_))
def testHardIncludesForEnums(self):
"""Tests that enums generate hard includes. Note that it's important to use
use a separate file (cross_enums) here to isolate the test case so that
other types don't cause the hard-dependency.
"""
m = model.Model()
m.AddNamespace(self.crossref_enums_json[0],
'path/to/crossref_enums.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.simple_api_json[0],
'path/to/simple_api.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(self.models.get('crossref_enums'),
_FakeSchemaLoader(m))
self.assertEqual('#include "path/to/simple_api.h"',
manager.GenerateIncludes().Render())
def testHardIncludesForEnumArrays(self):
"""Tests that enums in arrays generate hard includes. Note that it's
important to use a separate file (cross_enums_array) here to isolate the
test case so that other types don't cause the hard-dependency.
"""
m = model.Model()
m.AddNamespace(self.crossref_enums_array_json[0],
'path/to/crossref_enums_array.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.simple_api_json[0],
'path/to/simple_api.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(self.models.get('crossref_enums_array'),
_FakeSchemaLoader(m))
self.assertEqual('#include "path/to/simple_api.h"',
manager.GenerateIncludes().Render())
def testCrossNamespaceGetEnumDefaultValue(self):
m = model.Model()
m.AddNamespace(
self.simple_api_json[0],
'path/to/simple_api.json',
environment=CppNamespaceEnvironment('namespace1::api::%(namespace)s'))
m.AddNamespace(
self.crossref_enums_json[0],
'path/to/crossref_enum.json',
environment=CppNamespaceEnvironment('namespace2::api::%(namespace)s'))
manager = CppTypeGenerator(self.models.get('crossref_enums'),
_FakeSchemaLoader(m))
self.assertEqual(
'namespace1::api::simple_api::TestEnum()',
manager.GetEnumDefaultValue(
self.crossref_enums.types['CrossrefType'].
properties['testEnumOptional'].type_, self.crossref_enums))
if __name__ == '__main__':
unittest.main()
Codebase Browser
chromium