Added QMF tests for method invocation and numeric types.

Improved the swig typemaps to handle different numeric cases.


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

4 files changed, 210 insertions, 14 deletions

diff --git a/qpid/cpp/bindings/qmf/ruby/qmf.rb b/qpid/cpp/bindings/qmf/ruby/qmf.rb
index f3915e9c02..79b18423db 100644
--- a/qpid/cpp/bindings/qmf/ruby/qmf.rb
+++ b/qpid/cpp/bindings/qmf/ruby/qmf.rb
@@ -174,12 +174,19 @@ module Qmf
           @impl = Qmfengine::ObjectId.new
         end
       end
+
       def object_num_high
         return @impl.getObjectNumHi
       end
+
       def object_num_low
         return @impl.getObjectNumLo
       end
+
+      def ==(other)
+        return (@impl.getObjectNumHi == other.impl.getObjectNumHi) &&
+           (@impl.getObjectNumLo == other.impl.getObjectNumLo)
+      end
     end
 
     class Arguments
diff --git a/qpid/cpp/bindings/qmf/ruby/ruby.i b/qpid/cpp/bindings/qmf/ruby/ruby.i
index a8a2a87a97..8c2da1b494 100644
--- a/qpid/cpp/bindings/qmf/ruby/ruby.i
+++ b/qpid/cpp/bindings/qmf/ruby/ruby.i
@@ -43,7 +43,10 @@
 
 %typemap (in) uint32_t
 {
-    $1 = NUM2UINT ($input);
+    if (TYPE($input) == T_BIGNUM)
+        $1 = NUM2UINT($input);
+    else
+        $1 = FIX2UINT($input);
 }
 
 %typemap (out) uint32_t
@@ -51,6 +54,19 @@
     $result = UINT2NUM((unsigned int) $1);
 }
 
+%typemap (in) int32_t
+{
+    if (TYPE($input) == T_BIGNUM)
+        $1 = NUM2INT($input);
+    else
+        $1 = FIX2INT($input);
+}
+
+%typemap (out) int32_t
+{
+    $result = INT2NUM((int) $1);
+}
+
 %typemap (typecheck, precedence=SWIG_TYPECHECK_INTEGER) uint32_t {
    $1 = FIXNUM_P($input);
 }
@@ -62,7 +78,20 @@
 
 %typemap (out) uint64_t
 {
-    $result = ULONG2NUM((unsigned long) $1);
+    $result = ULONG2NUM((long) $1);
+}
+
+%typemap (in) int64_t
+{
+    if (TYPE($input) == T_BIGNUM)
+        $1 = NUM2LONG($input);
+    else
+        $1 = FIX2LONG($input);
+}
+
+%typemap (out) int64_t
+{
+    $result = LONG2NUM((long) $1);
 }
 
 %typemap (typecheck, precedence=SWIG_TYPECHECK_INTEGER) uint64_t {
diff --git a/qpid/cpp/bindings/qmf/tests/agent_ruby.rb b/qpid/cpp/bindings/qmf/tests/agent_ruby.rb
index 3f04b0ce2e..0f85c90f37 100755
--- a/qpid/cpp/bindings/qmf/tests/agent_ruby.rb
+++ b/qpid/cpp/bindings/qmf/tests/agent_ruby.rb
@@ -29,9 +29,27 @@ class Model
     @parent_class = Qmf::SchemaObjectClass.new("org.apache.qpid.qmf", "parent")
     @parent_class.add_property(Qmf::SchemaProperty.new("name", Qmf::TYPE_SSTR, :index => true))
     @parent_class.add_property(Qmf::SchemaProperty.new("state", Qmf::TYPE_SSTR))
+
+    @parent_class.add_property(Qmf::SchemaProperty.new("uint64val", Qmf::TYPE_UINT64))
     @parent_class.add_property(Qmf::SchemaProperty.new("uint32val", Qmf::TYPE_UINT32))
+    @parent_class.add_property(Qmf::SchemaProperty.new("uint16val", Qmf::TYPE_UINT16))
+    @parent_class.add_property(Qmf::SchemaProperty.new("uint8val", Qmf::TYPE_UINT8))
+
+    @parent_class.add_property(Qmf::SchemaProperty.new("int64val", Qmf::TYPE_INT64))
+    @parent_class.add_property(Qmf::SchemaProperty.new("int32val", Qmf::TYPE_INT32))
+    @parent_class.add_property(Qmf::SchemaProperty.new("int16val", Qmf::TYPE_INT16))
+    @parent_class.add_property(Qmf::SchemaProperty.new("int8val", Qmf::TYPE_INT8))
+
     @parent_class.add_statistic(Qmf::SchemaStatistic.new("queryCount", Qmf::TYPE_UINT32, :unit => "query", :desc => "Query count"))
 
+    method = Qmf::SchemaMethod.new("echo", :desc => "Check responsiveness of the agent object")
+    method.add_argument(Qmf::SchemaArgument.new("sequence", Qmf::TYPE_UINT32, :dir => Qmf::DIR_IN_OUT))
+    @parent_class.add_method(method)
+
+    method = Qmf::SchemaMethod.new("set_numerics", :desc => "Set the numeric values in the object")
+    method.add_argument(Qmf::SchemaArgument.new("test", Qmf::TYPE_SSTR, :dir => Qmf::DIR_IN))
+    @parent_class.add_method(method)
+
     method = Qmf::SchemaMethod.new("create_child", :desc => "Create a new child object")
     method.add_argument(Qmf::SchemaArgument.new("child_name", Qmf::TYPE_LSTR, :dir => Qmf::DIR_IN))
     method.add_argument(Qmf::SchemaArgument.new("child_ref", Qmf::TYPE_REF, :dir => Qmf::DIR_OUT))
@@ -55,18 +73,70 @@ class App < Qmf::AgentHandler
     #@parent.inc_attr("queryCount")
     if query.class_name == 'parent'
         @agent.query_response(context, @parent)
+    elsif query.object_id == @parent_oid
+        @agent.query_response(context, @parent)
     end
     @agent.query_complete(context)
   end
 
   def method_call(context, name, object_id, args, userId)
 #    puts "Method: user=#{userId} context=#{context} method=#{name} object_num=#{object_id.object_num_low if object_id} args=#{args}"
-    oid = @agent.alloc_object_id(2)
-    args['child_ref'] = oid
-    @child = Qmf::QmfObject.new(@model.child_class)
-    @child.set_attr("name", args.by_key("child_name"))
-    @child.set_object_id(oid)
-    @agent.method_response(context, 0, "OK", args)
+    
+    if name == "echo"
+      @agent.method_response(context, 0, "OK", args)
+
+    elsif name == "set_numerics"
+      retCode = 0
+      retText = "OK"
+
+      if args['test'] == "big"
+        @parent.set_attr("uint64val", 0x9494949449494949)
+        @parent.set_attr("uint32val", 0xa5a55a5a)
+        @parent.set_attr("uint16val", 0xb66b)
+        @parent.set_attr("uint8val",  0xc7)
+
+        @parent.set_attr("int64val", 1000000000000000000)
+        @parent.set_attr("int32val", 1000000000)
+        @parent.set_attr("int16val", 10000)
+        @parent.set_attr("int8val",  100)
+
+      elsif args['test'] == "small"
+        @parent.set_attr("uint64val", 4)
+        @parent.set_attr("uint32val", 5)
+        @parent.set_attr("uint16val", 6)
+        @parent.set_attr("uint8val",  7)
+
+        @parent.set_attr("int64val", 8)
+        @parent.set_attr("int32val", 9)
+        @parent.set_attr("int16val", 10)
+        @parent.set_attr("int8val",  11)
+
+      elsif args['test'] == "negative"
+        @parent.set_attr("uint64val", 0)
+        @parent.set_attr("uint32val", 0)
+        @parent.set_attr("uint16val", 0)
+        @parent.set_attr("uint8val",  0)
+
+        @parent.set_attr("int64val", -10000000000)
+        @parent.set_attr("int32val", -100000)
+        @parent.set_attr("int16val", -1000)
+        @parent.set_attr("int8val",  -100)
+
+      else
+        retCode = 1
+        retText = "Invalid argument value for test"
+      end
+
+      @agent.method_response(context, retCode, retText, args)
+
+    elsif name == "create_child"
+      oid = @agent.alloc_object_id(2)
+      args['child_ref'] = oid
+      @child = Qmf::QmfObject.new(@model.child_class)
+      @child.set_attr("name", args.by_key("child_name"))
+      @child.set_object_id(oid)
+      @agent.method_response(context, 0, "OK", args)
+    end
   end
 
   def main
@@ -84,10 +154,19 @@ class App < Qmf::AgentHandler
     @parent = Qmf::QmfObject.new(@model.parent_class)
     @parent.set_attr("name", "Parent One")
     @parent.set_attr("state", "OPERATIONAL")
-    @parent.set_attr("uint32val", 0xa5a5a5a5)
 
-    oid = @agent.alloc_object_id(1)
-    @parent.set_object_id(oid)
+    @parent.set_attr("uint64val", 0)
+    @parent.set_attr("uint32val", 0)
+    @parent.set_attr("uint16val", 0)
+    @parent.set_attr("uint8val",  0)
+
+    @parent.set_attr("int64val", 0)
+    @parent.set_attr("int32val", 0)
+    @parent.set_attr("int16val", 0)
+    @parent.set_attr("int8val",  0)
+
+    @parent_oid = @agent.alloc_object_id(1)
+    @parent.set_object_id(@parent_oid)
 
     sleep
   end
diff --git a/qpid/cpp/bindings/qmf/tests/python_console.py b/qpid/cpp/bindings/qmf/tests/python_console.py
index 7a8a2cb9fe..365f2ac33a 100755
--- a/qpid/cpp/bindings/qmf/tests/python_console.py
+++ b/qpid/cpp/bindings/qmf/tests/python_console.py
@@ -36,16 +36,97 @@ class QmfInteropTests(TestBase010):
             agents = qmf.getObjects(_class="agent")
             sleep(1)
             count += 1
-            if count > 5:
+            if count > 10:
                 self.fail("Timed out waiting for remote agent")
 
-    def test_B_basic_types(self):
+    def test_B_basic_method_invocation(self):
         self.startQmf();
         qmf = self.qmf
 
         parents = qmf.getObjects(_class="parent")
         self.assertEqual(len(parents), 1)
-        self.assertEqual(parents[0].uint32val, 0xA5A5A5A5)
+        parent = parents[0]
+        for seq in range(10):
+            result = parent.echo(seq)
+            self.assertEqual(result.status, 0)
+            self.assertEqual(result.text, "OK")
+            self.assertEqual(result.sequence, seq)
+
+        result = parent.set_numerics("bogus")
+        self.assertEqual(result.status, 1)
+        self.assertEqual(result.text, "Invalid argument value for test")
+
+    def test_C_basic_types_numeric_big(self):
+        self.startQmf();
+        qmf = self.qmf
+
+        parents = qmf.getObjects(_class="parent")
+        self.assertEqual(len(parents), 1)
+        parent = parents[0]
+
+        result = parent.set_numerics("big")
+        self.assertEqual(result.status, 0)
+        self.assertEqual(result.text, "OK")
+
+        parent.update()
+
+        self.assertEqual(parent.uint64val, 0x9494949449494949)
+        self.assertEqual(parent.uint32val, 0xA5A55A5A)
+        self.assertEqual(parent.uint16val, 0xB66B)
+        self.assertEqual(parent.uint8val,  0xC7)
+
+        self.assertEqual(parent.int64val, 1000000000000000000)
+        self.assertEqual(parent.int32val, 1000000000)
+        self.assertEqual(parent.int16val, 10000)
+        self.assertEqual(parent.int8val,  100)
+
+    def test_C_basic_types_numeric_small(self):
+        self.startQmf();
+        qmf = self.qmf
+
+        parents = qmf.getObjects(_class="parent")
+        self.assertEqual(len(parents), 1)
+        parent = parents[0]
+
+        result = parent.set_numerics("small")
+        self.assertEqual(result.status, 0)
+        self.assertEqual(result.text, "OK")
+
+        parent.update()
+
+        self.assertEqual(parent.uint64val, 4)
+        self.assertEqual(parent.uint32val, 5)
+        self.assertEqual(parent.uint16val, 6)
+        self.assertEqual(parent.uint8val,  7)
+
+        self.assertEqual(parent.int64val, 8)
+        self.assertEqual(parent.int32val, 9)
+        self.assertEqual(parent.int16val, 10)
+        self.assertEqual(parent.int8val,  11)
+
+    def test_C_basic_types_numeric_negative(self):
+        self.startQmf();
+        qmf = self.qmf
+
+        parents = qmf.getObjects(_class="parent")
+        self.assertEqual(len(parents), 1)
+        parent = parents[0]
+
+        result = parent.set_numerics("negative")
+        self.assertEqual(result.status, 0)
+        self.assertEqual(result.text, "OK")
+
+        parent.update()
+
+        self.assertEqual(parent.uint64val, 0)
+        self.assertEqual(parent.uint32val, 0)
+        self.assertEqual(parent.uint16val, 0)
+        self.assertEqual(parent.uint8val,  0)
+
+        self.assertEqual(parent.int64val, -10000000000)
+        self.assertEqual(parent.int32val, -100000)
+        self.assertEqual(parent.int16val, -1000)
+        self.assertEqual(parent.int8val,  -100)
 
     def getProperty(self, msg, name):
         for h in msg.headers: