QPID-2556: add tests for maps and lists in method args and events.

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk/qpid@938600 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 163 insertions, 15 deletions

diff --git a/cpp/bindings/qmf/tests/agent_ruby.rb b/cpp/bindings/qmf/tests/agent_ruby.rb
index bdc81f5c41..903e2dfc71 100755
--- a/cpp/bindings/qmf/tests/agent_ruby.rb
+++ b/cpp/bindings/qmf/tests/agent_ruby.rb
@@ -56,9 +56,11 @@ class Model
     method.add_argument(Qmf::SchemaArgument.new("test", Qmf::TYPE_SSTR, :dir => Qmf::DIR_IN))
     @parent_class.add_method(method)
 
-    method = Qmf::SchemaMethod.new("set_map", :desc => "Set the map value in the object")
-    method.add_argument(Qmf::SchemaArgument.new("value", Qmf::TYPE_MAP, :dir => Qmf::DIR_IN))
-    method.add_argument(Qmf::SchemaArgument.new("output", Qmf::TYPE_MAP, :dir => Qmf::DIR_OUT))
+    method = Qmf::SchemaMethod.new("test_map_list", :desc => "A method call that accepts map and list arguments.")
+    method.add_argument(Qmf::SchemaArgument.new("inMap", Qmf::TYPE_MAP, :dir => Qmf::DIR_IN))
+    method.add_argument(Qmf::SchemaArgument.new("inList", Qmf::TYPE_LIST, :dir => Qmf::DIR_IN))
+    method.add_argument(Qmf::SchemaArgument.new("outMap", Qmf::TYPE_MAP, :dir => Qmf::DIR_OUT))
+    method.add_argument(Qmf::SchemaArgument.new("outList", Qmf::TYPE_LIST, :dir => Qmf::DIR_OUT))
     @parent_class.add_method(method)
 
     method = Qmf::SchemaMethod.new("set_short_string", :desc => "Set the short string value in the object")
@@ -84,6 +86,8 @@ class Model
     @event_class = Qmf::SchemaEventClass.new("org.apache.qpid.qmf", "test_event", Qmf::SEV_INFORM)
     @event_class.add_argument(Qmf::SchemaArgument.new("uint32val", Qmf::TYPE_UINT32))
     @event_class.add_argument(Qmf::SchemaArgument.new("strval", Qmf::TYPE_LSTR))
+    @event_class.add_argument(Qmf::SchemaArgument.new("mapval", Qmf::TYPE_MAP))
+    @event_class.add_argument(Qmf::SchemaArgument.new("listval", Qmf::TYPE_LIST))
   end
 
   def register(agent)
@@ -114,12 +118,22 @@ class App < Qmf::AgentHandler
     if name == "echo"
       @agent.method_response(context, 0, "OK", args)
 
-    elsif name == "set_map"
+    elsif name == "test_map_list"
+      # build the output map from the input map, accessing each key,
+      # value to ensure they are encoded/decoded
+      outMap = {}
+      args['inMap'].each do |k,v|
+        outMap[k] = v
+      end
 
-      map = args['value']
+      # same deal for the output list
+      outList = []
+      args['inList'].each do |v|
+        outList << v
+      end
 
-      map['added'] = 'Added Text'
-      args['output'] = map
+      args['outMap'] = outMap
+      args['outList'] = outList
 
     elsif name == "set_numerics"
 
@@ -137,6 +151,8 @@ class App < Qmf::AgentHandler
         event = Qmf::QmfEvent.new(@model.event_class)
         event.uint32val = @parent.uint32val
         event.strval = "Unused"
+        event.mapval = @parent.mapval
+        event.listval = @parent.listval
         @agent.raise_event(event)
 
       elsif args['test'] == "small"
diff --git a/cpp/bindings/qmf/tests/python_agent.py b/cpp/bindings/qmf/tests/python_agent.py
index 1003ce875a..e22c80a813 100644
--- a/cpp/bindings/qmf/tests/python_agent.py
+++ b/cpp/bindings/qmf/tests/python_agent.py
@@ -58,9 +58,11 @@ class Model:
         _method.add_argument(qmf.SchemaArgument("test", qmf.TYPE_SSTR, {"dir":qmf.DIR_IN}))
         self.parent_class.add_method(_method)
 
-        _method = qmf.SchemaMethod("set_map", {"desc":"Set the map value in the object"})
-        _method.add_argument(qmf.SchemaArgument("value", qmf.TYPE_MAP, {"dir":qmf.DIR_IN}))
-        _method.add_argument(qmf.SchemaArgument("output", qmf.TYPE_MAP, {"dir":qmf.DIR_OUT}))
+        _method = qmf.SchemaMethod("test_map_list", {"desc":"A method call that accepts map and list arguments."})
+        _method.add_argument(qmf.SchemaArgument("inMap", qmf.TYPE_MAP, {"dir":qmf.DIR_IN}))
+        _method.add_argument(qmf.SchemaArgument("inList", qmf.TYPE_LIST, {"dir":qmf.DIR_IN}))
+        _method.add_argument(qmf.SchemaArgument("outMap", qmf.TYPE_MAP, {"dir":qmf.DIR_OUT}))
+        _method.add_argument(qmf.SchemaArgument("outList", qmf.TYPE_LIST, {"dir":qmf.DIR_OUT}))
         self.parent_class.add_method(_method)
 
         _method = qmf.SchemaMethod("set_short_string", {"desc":"Set the short string value in the object"})
@@ -86,7 +88,8 @@ class Model:
         self.event_class = qmf.SchemaEventClass("org.apache.qpid.qmf", "test_event", qmf.SEV_NOTICE)
         self.event_class.add_argument(qmf.SchemaArgument("uint32val", qmf.TYPE_UINT32))
         self.event_class.add_argument(qmf.SchemaArgument("strval", qmf.TYPE_LSTR))
-
+        self.event_class.add_argument(qmf.SchemaArgument("mapval", qmf.TYPE_MAP))
+        self.event_class.add_argument(qmf.SchemaArgument("listval", qmf.TYPE_LIST))
 
     def register(self, agent):
         agent.register_class(self.parent_class)
@@ -122,10 +125,20 @@ class App(qmf.AgentHandler):
         if name == "echo":
             self._agent.method_response(context, 0, "OK", args)
 
-        elif name == "set_map":
-            map = args['value']
-            map['added'] = "Added Text"
-            args['output'] = map
+        elif name == "test_map_list":
+            # build the output map from the input map, accessing each key,
+            # value to ensure they are encoded/decoded
+            outMap = {}
+            for key,value in args['inMap'].items():
+                outMap[key] = value
+
+            # same deal for the output list
+            outList = []
+            for value in args['inList']:
+                outList.append(value)
+
+            args['outMap'] = outMap
+            args['outList'] = outList
             self._agent.method_response(context, 0, "OK", args)
 
         elif name == "set_numerics":
@@ -149,6 +162,8 @@ class App(qmf.AgentHandler):
                 event = qmf.QmfEvent(self._model.event_class)
                 event.uint32val = self._parent.get_attr("uint32val")
                 event.strval = "Unused"
+                event.mapval = self._parent.get_attr("mapval")
+                event.listval = self._parent["listval"]
 
                 self._agent.raise_event(event)
 
diff --git a/cpp/bindings/qmf/tests/python_console.py b/cpp/bindings/qmf/tests/python_console.py
index d8e75cc294..6ed3c04d50 100755
--- a/cpp/bindings/qmf/tests/python_console.py
+++ b/cpp/bindings/qmf/tests/python_console.py
@@ -194,6 +194,34 @@ class QmfInteropTests(TestBase010):
         self.assertEqual(len(queue), 5)
         self.assertEqual(queue[0].arguments["uint32val"], 0xA5A55A5A)
         self.assertEqual(queue[0].arguments["strval"], "Unused")
+
+        # verify map and list event content.
+        # see agent for structure of listval and mapval
+        listval = queue[0].arguments["listval"]
+        self.assertTrue(isinstance(listval, list))
+        self.assertEqual(len(listval), 5)
+        self.assertTrue(isinstance(listval[4], list))
+        self.assertEqual(len(listval[4]), 4)
+        self.assertTrue(isinstance(listval[4][3], dict))
+        self.assertEqual(listval[4][3]["hi"], 10)
+        self.assertEqual(listval[4][3]["lo"], 5)
+        self.assertEqual(listval[4][3]["neg"], -3)
+
+        mapval = queue[0].arguments["mapval"]
+        self.assertTrue(isinstance(mapval, dict))
+        self.assertEqual(len(mapval), 7)
+        self.assertEqual(mapval['aLong'], 9999999999)
+        self.assertEqual(mapval['aInt'], 54321)
+        self.assertEqual(mapval['aSigned'], -666)
+        self.assertEqual(mapval['aString'], "A String"),
+        self.assertEqual(mapval['aFloat'], 3.1415),
+        self.assertTrue(isinstance(mapval['aMap'], dict))
+        self.assertEqual(len(mapval['aMap']), 2)
+        self.assertEqual(mapval['aMap']['second'], 2)
+        self.assertTrue(isinstance(mapval['aList'], list))
+        self.assertEqual(len(mapval['aList']), 4)
+        self.assertEqual(mapval['aList'][1], -1)
+
         self.assertEqual(queue[1].arguments["uint32val"], 5)
         self.assertEqual(queue[1].arguments["strval"], "Unused")
         self.assertEqual(queue[2].arguments["uint32val"], 0)
@@ -204,6 +232,7 @@ class QmfInteropTests(TestBase010):
         self.assertEqual(queue[4].arguments["strval"], "LONG_TEST")
 
 
+
     def test_G_basic_map_list_data(self):
         self.startQmf();
         qmf = self.qmf
@@ -239,6 +268,36 @@ class QmfInteropTests(TestBase010):
         self.assertEqual(len(parent.mapval['aList']), 4)
         self.assertEqual(parent.mapval['aList'][1], -1)
 
+    def test_H_map_list_method_call(self):
+        self.startQmf();
+        qmf = self.qmf
+
+        parents = qmf.getObjects(_class="parent")
+        self.assertEqual(len(parents), 1)
+        parent = parents[0]
+
+        inMap = {'aLong' : long(9999999999),
+                 'aInt'  : int(54321),
+                 'aSigned' : -666,
+                 'aString' : "A String",
+                 'aFloat' : 3.1415,
+                 'aList' : ['x', -1, 'y', 2]}
+
+        inList = ['aString', long(1), -1, 2.7182, {'aMap': -8}]
+
+        result = parent.test_map_list(inMap, inList)
+        self.assertEqual(result.status, 0)
+        self.assertEqual(result.text, "OK")
+
+        # verify returned values
+        self.assertEqual(len(inMap), len(result.outArgs['outMap']))
+        for key,value in result.outArgs['outMap'].items():
+            self.assertEqual(inMap[key], value)
+
+        self.assertEqual(len(inList), len(result.outArgs['outList']))
+        for idx in range(len(inList)):
+            self.assertEqual(inList[idx], result.outArgs['outList'][idx])
+
 
     def getProperty(self, msg, name):
         for h in msg.headers:
diff --git a/cpp/bindings/qmf/tests/ruby_console_test.rb b/cpp/bindings/qmf/tests/ruby_console_test.rb
index 0782ae795a..4d65afa79d 100755
--- a/cpp/bindings/qmf/tests/ruby_console_test.rb
+++ b/cpp/bindings/qmf/tests/ruby_console_test.rb
@@ -250,6 +250,35 @@ class ConsoleTest < ConsoleTestBase
 
     assert_equal(@event_list[0].get_attr("uint32val"), 0xA5A55A5A)
     assert_equal(@event_list[0].get_attr("strval"), "Unused")
+
+    # verify map and list event content.
+    # see agent for structure of listval and mapval
+
+    listval = @event_list[0].listval
+    assert(listval.class == Array)
+    assert_equal(listval.length, 5)
+    assert(listval[4].class == Array)
+    assert_equal(listval[4].length, 4)
+    assert(listval[4][3].class == Hash)
+    assert_equal(listval[4][3]["hi"], 10)
+    assert_equal(listval[4][3]["lo"], 5)
+    assert_equal(listval[4][3]["neg"], -3)
+
+    mapval = @event_list[0].mapval
+    assert(mapval.class == Hash)
+    assert_equal(mapval.length, 7)
+    assert_equal(mapval['aLong'], 9999999999)
+    assert_equal(mapval['aInt'], 54321)
+    assert_equal(mapval['aSigned'], -666)
+    assert_equal(mapval['aString'], "A String")
+    assert_equal(mapval['aFloat'], 3.1415)
+    assert(mapval['aMap'].class == Hash)
+    assert_equal(mapval['aMap'].length, 2)
+    assert_equal(mapval['aMap']['second'], 2)
+    assert(mapval['aList'].class == Array)
+    assert_equal(mapval['aList'].length, 4)
+    assert_equal(mapval['aList'][1], -1)
+
     assert_equal(@event_list[1]["uint32val"], 5)
     assert_equal(@event_list[1].get_attr("strval"), "Unused")
     assert_equal(@event_list[2].get_attr("uint32val"), 0)
@@ -295,6 +324,35 @@ class ConsoleTest < ConsoleTestBase
     assert_equal(parent.mapval['aList'][1], -1)
   end
 
+  def test_H_map_list_method_call
+    parent = @qmfc.object(:class => "parent")
+    assert(parent, "Number of 'parent' objects")
+
+    inMap = {'aLong' => 9999999999,
+             'aInt'  => 54321,
+             'aSigned' => -666,
+             'aString' => "A String",
+             'aFloat' => 3.1415,
+             'aList' => ['x', -1, 'y', 2]}
+
+    inList = ['aString', 1, -1, 2.7182, {'aMap'=> -8}]
+
+    result = parent.test_map_list(inMap, inList)
+    assert_equal(result.status, 0)
+    assert_equal(result.text, "OK")
+
+    # verify returned values
+    assert_equal(inMap.length, result.args['outMap'].length)
+    result.args['outMap'].each do |k,v|
+      assert_equal(inMap[k], v)
+    end
+
+    assert_equal(inList.length, result.args['outList'].length)
+    for idx in 0...inList.length
+      assert_equal(inList[idx], result.args['outList'][idx])
+    end
+  end
+
 end
 
 app = ConsoleTest.new