summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--tools/json_schema_compiler/idl_schema.py15
-rwxr-xr-xtools/json_schema_compiler/idl_schema_test.py47
-rw-r--r--tools/json_schema_compiler/test/idl_basics.idl6
-rw-r--r--tools/json_schema_compiler/test/idl_schemas_unittest.cc50
4 files changed, 115 insertions, 3 deletions
diff --git a/tools/json_schema_compiler/idl_schema.py b/tools/json_schema_compiler/idl_schema.py
index 9779e27..1d3c83a 100644
--- a/tools/json_schema_compiler/idl_schema.py
+++ b/tools/json_schema_compiler/idl_schema.py
@@ -108,10 +108,20 @@ class Typeref(object):
def process(self, refs):
properties = self.additional_properties
+ result = properties
if self.parent.GetProperty('OPTIONAL', False):
properties['optional'] = True
+ # The IDL parser denotes array types by adding a child 'Array' node onto
+ # the Param node in the Callspec.
+ for sibling in self.parent.GetChildren():
+ if sibling.cls == 'Array' and sibling.GetName() == self.parent.GetName():
+ properties['type'] = 'array'
+ properties['items'] = {}
+ properties = properties['items']
+ break
+
if self.typeref == 'DOMString':
properties['type'] = 'string'
elif self.typeref == 'boolean':
@@ -132,10 +142,11 @@ class Typeref(object):
properties['type'] = 'function'
else:
try:
- properties = refs[self.typeref]
+ result = refs[self.typeref]
except KeyError, e:
properties['$ref'] = self.typeref
- return properties
+
+ return result
class Namespace(object):
'''
diff --git a/tools/json_schema_compiler/idl_schema_test.py b/tools/json_schema_compiler/idl_schema_test.py
new file mode 100755
index 0000000..59fcd6d
--- /dev/null
+++ b/tools/json_schema_compiler/idl_schema_test.py
@@ -0,0 +1,47 @@
+#!/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
+
+def getFunction(schema, name):
+ for item in schema['functions']:
+ if item['name'] == name:
+ return item
+ raise KeyError('Missing function %s' % name)
+
+def getParams(schema, name):
+ function = getFunction(schema, name)
+ return function['parameters']
+
+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]
+
+ def testSimpleCallbacks(self):
+ schema = self.idl_basics
+ expected = [{'type':'function', 'name':'Callback1', 'parameters':[]}]
+ self.assertEquals(expected, getParams(schema, 'function4'))
+
+ expected = [{'type':'function', 'name':'Callback2',
+ 'parameters':[{'name':'x', 'type':'integer'}]}]
+ self.assertEquals(expected, getParams(schema, 'function5'))
+
+ expected = [{'type':'function', 'name':'Callback3',
+ 'parameters':[{'name':'arg', '$ref':'MyType1'}]}]
+ self.assertEquals(expected, getParams(schema, 'function6'))
+
+ def testCallbackWithArrayArgument(self):
+ schema = self.idl_basics
+ expected = [{'type':'function', 'name':'Callback4',
+ 'parameters':[{'name':'arg', 'type':'array',
+ 'items':{'$ref':'MyType2'}}]}]
+ self.assertEquals(expected, getParams(schema, 'function12'))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tools/json_schema_compiler/test/idl_basics.idl b/tools/json_schema_compiler/test/idl_basics.idl
index 32489ff..3947ed9 100644
--- a/tools/json_schema_compiler/test/idl_basics.idl
+++ b/tools/json_schema_compiler/test/idl_basics.idl
@@ -17,6 +17,7 @@ namespace idl_basics {
callback Callback1 = void();
callback Callback2 = void(long x);
callback Callback3 = void(MyType1 arg);
+ callback Callback4 = void(MyType2[] arg);
interface Functions {
static void function1();
@@ -30,6 +31,11 @@ namespace idl_basics {
static void function7(optional long arg);
static void function8(long arg1, optional DOMString arg2);
static void function9(optional MyType1 arg);
+
+ static void function10(long x, long[] y);
+ static void function11(MyType1[] arg);
+
+ static void function12(Callback4 cb);
};
interface Events {
diff --git a/tools/json_schema_compiler/test/idl_schemas_unittest.cc b/tools/json_schema_compiler/test/idl_schemas_unittest.cc
index 6bad12f..4969a9b 100644
--- a/tools/json_schema_compiler/test/idl_schemas_unittest.cc
+++ b/tools/json_schema_compiler/test/idl_schemas_unittest.cc
@@ -21,6 +21,8 @@ namespace Function6 = test::api::idl_basics::Function6;
namespace Function7 = test::api::idl_basics::Function7;
namespace Function8 = test::api::idl_basics::Function8;
namespace Function9 = test::api::idl_basics::Function9;
+namespace Function10 = test::api::idl_basics::Function10;
+namespace Function11 = test::api::idl_basics::Function11;
namespace ObjectFunction1 = test::api::idl_object_types::ObjectFunction1;
TEST(IdlCompiler, Basics) {
@@ -66,7 +68,7 @@ TEST(IdlCompiler, Basics) {
}
TEST(IdlCompiler, OptionalArguments) {
- // Test a function that takes one optional argument, but without and with
+ // Test a function that takes one optional argument, both without and with
// that argument.
ListValue list;
scoped_ptr<Function7::Params> f7_params = Function7::Params::Create(list);
@@ -103,6 +105,52 @@ TEST(IdlCompiler, OptionalArguments) {
EXPECT_EQ("hello", t1->y);
}
+TEST(IdlCompiler, ArrayTypes) {
+ // Tests of a function that takes an integer and an array of integers. First
+ // use an empty array.
+ ListValue list;
+ list.Append(Value::CreateIntegerValue(33));
+ list.Append(new ListValue);
+ scoped_ptr<Function10::Params> f10_params = Function10::Params::Create(list);
+ ASSERT_TRUE(f10_params != NULL);
+ EXPECT_EQ(33, f10_params->x);
+ EXPECT_TRUE(f10_params->y.empty());
+
+ // Same function, but this time with 2 values in the array.
+ list.Clear();
+ list.Append(Value::CreateIntegerValue(33));
+ ListValue* sublist = new ListValue;
+ sublist->Append(Value::CreateIntegerValue(34));
+ sublist->Append(Value::CreateIntegerValue(35));
+ list.Append(sublist);
+ f10_params = Function10::Params::Create(list);
+ ASSERT_TRUE(f10_params != NULL);
+ EXPECT_EQ(33, f10_params->x);
+ ASSERT_EQ(2u, f10_params->y.size());
+ EXPECT_EQ(34, f10_params->y[0]);
+ EXPECT_EQ(35, f10_params->y[1]);
+
+ // Now test a function which takes an array of a defined type.
+ list.Clear();
+ MyType1 a;
+ MyType1 b;
+ a.x = 5;
+ b.x = 6;
+ a.y = std::string("foo");
+ b.y = std::string("bar");
+ ListValue* sublist2 = new ListValue;
+ sublist2->Append(a.ToValue().release());
+ sublist2->Append(b.ToValue().release());
+ list.Append(sublist2);
+ scoped_ptr<Function11::Params> f11_params = Function11::Params::Create(list);
+ ASSERT_TRUE(f11_params != NULL);
+ ASSERT_EQ(2u, f11_params->arg.size());
+ EXPECT_EQ(5, f11_params->arg[0]->x);
+ EXPECT_EQ("foo", f11_params->arg[0]->y);
+ EXPECT_EQ(6, f11_params->arg[1]->x);
+ EXPECT_EQ("bar", f11_params->arg[1]->y);
+}
+
TEST(IdlCompiler, ObjectTypes) {
// Test the FooType type.
FooType f1;
generated by cgit v1.1 at 2025-01-10 18:00:11 +0000