[libnet-dbus-perl] 188/335: Added support for int16/uint16
Intrigeri
intrigeri at moszumanska.debian.org
Sat Mar 21 01:07:52 UTC 2015
This is an automated email from the git hooks/post-receive script.
intrigeri pushed a commit to branch experimental
in repository libnet-dbus-perl.
commit c4d6b0727b39d6c1c2ce067daca083d03d88bbdf
Author: Daniel P. Berrange <berrange at redhat.com>
Date: Sun Feb 19 11:55:29 2006 -0500
Added support for int16/uint16
---
DBus.xs | 36 ++++
lib/Net/DBus.pm | 28 ++-
lib/Net/DBus/Binding/Introspector.pm | 4 +
lib/Net/DBus/Binding/Iterator.pm | 22 +++
lib/Net/DBus/Binding/Message.pm | 10 +
lib/Net/DBus/Exporter.pm | 8 +
t/15-message.t | 9 +-
t/56-scalar-param-typing.t | 350 ++++++++++++++++++++++++++++++++++-
typemap | 2 +
9 files changed, 465 insertions(+), 4 deletions(-)
diff --git a/DBus.xs b/DBus.xs
index c940c3b..79d31cb 100644
--- a/DBus.xs
+++ b/DBus.xs
@@ -385,6 +385,7 @@ BOOT:
REGISTER_CONSTANT(DBUS_TYPE_BOOLEAN, TYPE_BOOLEAN);
REGISTER_CONSTANT(DBUS_TYPE_BYTE, TYPE_BYTE);
REGISTER_CONSTANT(DBUS_TYPE_DOUBLE, TYPE_DOUBLE);
+ REGISTER_CONSTANT(DBUS_TYPE_INT16, TYPE_INT16);
REGISTER_CONSTANT(DBUS_TYPE_INT32, TYPE_INT32);
REGISTER_CONSTANT(DBUS_TYPE_INT64, TYPE_INT64);
REGISTER_CONSTANT(DBUS_TYPE_INVALID, TYPE_INVALID);
@@ -393,6 +394,7 @@ BOOT:
REGISTER_CONSTANT(DBUS_TYPE_OBJECT_PATH, TYPE_OBJECT_PATH);
REGISTER_CONSTANT(DBUS_TYPE_DICT_ENTRY, TYPE_DICT_ENTRY);
REGISTER_CONSTANT(DBUS_TYPE_STRING, TYPE_STRING);
+ REGISTER_CONSTANT(DBUS_TYPE_UINT16, TYPE_UINT16);
REGISTER_CONSTANT(DBUS_TYPE_UINT32, TYPE_UINT32);
REGISTER_CONSTANT(DBUS_TYPE_UINT64, TYPE_UINT64);
REGISTER_CONSTANT(DBUS_TYPE_VARIANT, TYPE_VARIANT);
@@ -1144,6 +1146,22 @@ get_byte(iter)
OUTPUT:
RETVAL
+dbus_int16_t
+get_int16(iter)
+ DBusMessageIter *iter;
+ CODE:
+ dbus_message_iter_get_basic(iter, &RETVAL);
+ OUTPUT:
+ RETVAL
+
+dbus_uint16_t
+get_uint16(iter)
+ DBusMessageIter *iter;
+ CODE:
+ dbus_message_iter_get_basic(iter, &RETVAL);
+ OUTPUT:
+ RETVAL
+
dbus_int32_t
get_int32(iter)
DBusMessageIter *iter;
@@ -1212,6 +1230,24 @@ append_byte(iter, val)
}
void
+append_int16(iter, val)
+ DBusMessageIter *iter;
+ dbus_int16_t val;
+ CODE:
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_INT16, &val)) {
+ croak("cannot append int16");
+ }
+
+void
+append_uint16(iter, val)
+ DBusMessageIter *iter;
+ dbus_uint16_t val;
+ CODE:
+ if (!dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT16, &val)) {
+ croak("cannot append uint16");
+ }
+
+void
append_int32(iter, val)
DBusMessageIter *iter;
dbus_int32_t val;
diff --git a/lib/Net/DBus.pm b/lib/Net/DBus.pm
index 6ed5ef7..509a944 100644
--- a/lib/Net/DBus.pm
+++ b/lib/Net/DBus.pm
@@ -109,11 +109,11 @@ use Exporter qw(import);
use vars qw(@EXPORT_OK %EXPORT_TAGS);
- at EXPORT_OK = qw(dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
+ at EXPORT_OK = qw(dbus_int16 dbus_uint16 dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
dbus_byte dbus_boolean dbus_string dbus_double
dbus_struct dbus_array dbus_dict);
-%EXPORT_TAGS = (typing => [qw(dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
+%EXPORT_TAGS = (typing => [qw(dbus_int16 dbus_uint16 dbus_int32 dbus_uint32 dbus_int64 dbus_uint64
dbus_byte dbus_boolean dbus_string dbus_double
dbus_struct dbus_array dbus_dict)]);
@@ -518,6 +518,30 @@ specifying 'use Net::DBus qw(:typing)'
=over 4
+=item $typed_value = dbus_int16($value);
+
+Mark a value as being a signed, 16-bit integer.
+
+=cut
+
+sub dbus_int16 {
+ return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_INT16,
+ $_[0]);
+
+}
+
+=item $typed_value = dbus_uint16($value);
+
+Mark a value as being an unsigned, 16-bit integer.
+
+=cut
+
+
+sub dbus_uint16 {
+ return Net::DBus::Binding::Value->new(&Net::DBus::Binding::Message::TYPE_UINT16,
+ $_[0]);
+}
+
=item $typed_value = dbus_int32($value);
Mark a value as being a signed, 32-bit integer.
diff --git a/lib/Net/DBus/Binding/Introspector.pm b/lib/Net/DBus/Binding/Introspector.pm
index 6b5ccbe..d1085a8 100644
--- a/lib/Net/DBus/Binding/Introspector.pm
+++ b/lib/Net/DBus/Binding/Introspector.pm
@@ -67,6 +67,8 @@ our %simple_type_map = (
"bool" => &Net::DBus::Binding::Message::TYPE_BOOLEAN,
"double" => &Net::DBus::Binding::Message::TYPE_DOUBLE,
"string" => &Net::DBus::Binding::Message::TYPE_STRING,
+ "int16" => &Net::DBus::Binding::Message::TYPE_INT16,
+ "uint16" => &Net::DBus::Binding::Message::TYPE_UINT16,
"int32" => &Net::DBus::Binding::Message::TYPE_INT32,
"uint32" => &Net::DBus::Binding::Message::TYPE_UINT32,
"int64" => &Net::DBus::Binding::Message::TYPE_INT64,
@@ -80,6 +82,8 @@ our %simple_type_rev_map = (
&Net::DBus::Binding::Message::TYPE_BOOLEAN => "bool",
&Net::DBus::Binding::Message::TYPE_DOUBLE => "double",
&Net::DBus::Binding::Message::TYPE_STRING => "string",
+ &Net::DBus::Binding::Message::TYPE_INT16 => "int16",
+ &Net::DBus::Binding::Message::TYPE_UINT16 => "uint16",
&Net::DBus::Binding::Message::TYPE_INT32 => "int32",
&Net::DBus::Binding::Message::TYPE_UINT32 => "uint32",
&Net::DBus::Binding::Message::TYPE_INT64 => "int64",
diff --git a/lib/Net/DBus/Binding/Iterator.pm b/lib/Net/DBus/Binding/Iterator.pm
index 0ebf9fa..9f53dcc 100644
--- a/lib/Net/DBus/Binding/Iterator.pm
+++ b/lib/Net/DBus/Binding/Iterator.pm
@@ -119,6 +119,20 @@ message iterator.
Read or write a UTF-8 string value from/to the
message iterator
+=item my $val = $iter->get_int16()
+
+=item $iter->append_int16($val);
+
+Read or write a signed 16 bit value from/to the
+message iterator
+
+=item my $val = $iter->get_uint16()
+
+=item $iter->append_uint16($val);
+
+Read or write an unsigned 16 bit value from/to the
+message iterator
+
=item my $val = $iter->get_int32()
=item $iter->append_int32($val);
@@ -231,6 +245,10 @@ sub get {
return $self->get_boolean;
} elsif ($type == &Net::DBus::Binding::Message::TYPE_BYTE) {
return $self->get_byte;
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_INT16) {
+ return $self->get_int16;
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT16) {
+ return $self->get_uint16;
} elsif ($type == &Net::DBus::Binding::Message::TYPE_INT32) {
return $self->get_int32;
} elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT32) {
@@ -413,6 +431,10 @@ sub append {
$self->append_byte($value);
} elsif ($type == &Net::DBus::Binding::Message::TYPE_STRING) {
$self->append_string($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_INT16) {
+ $self->append_int16($value);
+ } elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT16) {
+ $self->append_uint16($value);
} elsif ($type == &Net::DBus::Binding::Message::TYPE_INT32) {
$self->append_int32($value);
} elsif ($type == &Net::DBus::Binding::Message::TYPE_UINT32) {
diff --git a/lib/Net/DBus/Binding/Message.pm b/lib/Net/DBus/Binding/Message.pm
index e9c238b..c1a1355 100644
--- a/lib/Net/DBus/Binding/Message.pm
+++ b/lib/Net/DBus/Binding/Message.pm
@@ -78,6 +78,11 @@ dictionary entry data type.
Constant representing the signature value associated with the
IEEE double precision floating point data type.
+=item TYPE_INT16
+
+Constant representing the signature value associated with the
+signed 16 bit integer data type.
+
=item TYPE_INT32
Constant representing the signature value associated with the
@@ -103,6 +108,11 @@ UTF-8 string data type.
Constant representing the signature value associated with the
struct data type.
+=item TYPE_UINT16
+
+Constant representing the signature value associated with the
+unsigned 16 bit integer data type.
+
=item TYPE_UINT32
Constant representing the signature value associated with the
diff --git a/lib/Net/DBus/Exporter.pm b/lib/Net/DBus/Exporter.pm
index 05cb9fc..c514854 100644
--- a/lib/Net/DBus/Exporter.pm
+++ b/lib/Net/DBus/Exporter.pm
@@ -77,6 +77,14 @@ they are represented as the Perl SCALAR data type (see L<perldata>).
A UTF-8 string of characters
+=item "int16"
+
+A 16-bit signed integer
+
+=item "uint16"
+
+A 16-bit unsigned integer
+
=item "int32"
A 32-bit signed integer
diff --git a/t/15-message.t b/t/15-message.t
index b058c1f..9cccd73 100644
--- a/t/15-message.t
+++ b/t/15-message.t
@@ -1,5 +1,5 @@
# -*- perl -*-
-use Test::More tests => 21;
+use Test::More tests => 25;
BEGIN {
use_ok('Net::DBus::Binding::Iterator');
use_ok('Net::DBus::Binding::Message::Signal');
@@ -16,6 +16,8 @@ my $msg = Net::DBus::Binding::Message::Signal->new(object_path => "/foo/bar/Wizz
my $iter = $msg->iterator(1);
$iter->append_boolean(1);
$iter->append_byte(43);
+$iter->append_int16(123);
+$iter->append_uint16(456);
$iter->append_int32(123);
$iter->append_uint32(456);
if ($Net::DBus::Binding::Iterator::have_quads) {
@@ -34,6 +36,11 @@ ok($iter->next(), "next");
ok($iter->get_byte() == 43, "byte");
ok($iter->next(), "next");
+ok($iter->get_int16() == 123, "int16");
+ok($iter->next(), "next");
+ok($iter->get_uint16() == 456, "uint16");
+ok($iter->next(), "next");
+
ok($iter->get_int32() == 123, "int32");
ok($iter->next(), "next");
ok($iter->get_uint32() == 456, "uint32");
diff --git a/t/56-scalar-param-typing.t b/t/56-scalar-param-typing.t
index 187ddf2..5dd73e8 100644
--- a/t/56-scalar-param-typing.t
+++ b/t/56-scalar-param-typing.t
@@ -1,6 +1,6 @@
# -*- perl -*-
-use Test::More tests => 256;
+use Test::More tests => 382;
use strict;
use warnings;
@@ -30,6 +30,103 @@ TEST_NO_INTROSPECT: {
is($object->get_last_message_param, "5.234", "double as string");
+ #### INT 16 tests
+
+ # Positive integers
+ $myobject->ScalarInt16("2");
+ is($object->get_last_message_signature, "s", "string as int16");
+ is($object->get_last_message_param, "2", "string as int16");
+
+ $myobject->ScalarInt16(2);
+ is($object->get_last_message_signature, "s", "int as int16");
+ is($object->get_last_message_param, "2", "int as int16");
+
+ $myobject->ScalarInt16(2.0);
+ is($object->get_last_message_signature, "s", "double as int16");
+ is($object->get_last_message_param, "2", "double as int16");
+
+ # Negative integers
+ $myobject->ScalarInt16("-2");
+ is($object->get_last_message_signature, "s", "-ve string as int16");
+ is($object->get_last_message_param, "-2", "-ve string as int16");
+
+ $myobject->ScalarInt16(-2);
+ is($object->get_last_message_signature, "s", "-ve int as int16");
+ is($object->get_last_message_param, "-2", "-ve int as int16");
+
+ $myobject->ScalarInt16(-2.0);
+ is($object->get_last_message_signature, "s", "-ve double as int16");
+ is($object->get_last_message_param, "-2", "-ve double as int16");
+
+ # Rounding of doubles
+ $myobject->ScalarInt16(2.1);
+ is($object->get_last_message_signature, "s", "round down double as int16");
+ is($object->get_last_message_param, "2.1", "round down double as int16");
+
+ $myobject->ScalarInt16(2.9);
+ is($object->get_last_message_signature, "s", "round up double as int16");
+ is($object->get_last_message_param, "2.9", "round up double as int16");
+
+ $myobject->ScalarInt16(2.5);
+ is($object->get_last_message_signature, "s", "round up double threshold as int16");
+ is($object->get_last_message_param, "2.5", "round up double threshold as int16");
+
+ $myobject->ScalarInt16(-2.1);
+ is($object->get_last_message_signature, "s", "-ve round up double as int16");
+ is($object->get_last_message_param, "-2.1", "-ve round up double as int16");
+
+ $myobject->ScalarInt16(-2.9);
+ is($object->get_last_message_signature, "s", "-ve round down double as int16");
+ is($object->get_last_message_param, "-2.9", "-ve round down double as int16");
+
+ $myobject->ScalarInt16(-2.5);
+ is($object->get_last_message_signature, "s", "-ve round down double threshold as int16");
+ is($object->get_last_message_param, "-2.5", "-ve round down double threshold as int16");
+
+
+ #### UINT 16 tests
+
+ # Positive integers
+ $myobject->ScalarUInt16("2");
+ is($object->get_last_message_signature, "s", "string as uint16");
+ is($object->get_last_message_param, "2", "string as uint16");
+
+ $myobject->ScalarUInt16(2);
+ is($object->get_last_message_signature, "s", "int as uint16");
+ is($object->get_last_message_param, "2", "int as uint16");
+
+ $myobject->ScalarUInt16(2.0);
+ is($object->get_last_message_signature, "s", "double as uint16");
+ is($object->get_last_message_param, "2", "double as uint16");
+
+ # Negative integers
+ $myobject->ScalarUInt16("-2");
+ is($object->get_last_message_signature, "s", "-ve string as uint16");
+ is($object->get_last_message_param, "-2", "-ve string as uint16");
+
+ $myobject->ScalarUInt16(-2);
+ is($object->get_last_message_signature, "s", "-ve int as uint16");
+ is($object->get_last_message_param, "-2", "-ve int as uint16");
+
+ $myobject->ScalarUInt16(-2.0);
+ is($object->get_last_message_signature, "s", "-ve double as uint16");
+ is($object->get_last_message_param, "-2", "-ve double as uint16");
+
+
+ # Rounding of doubles
+ $myobject->ScalarUInt16(2.1);
+ is($object->get_last_message_signature, "s", "round down double as uint16");
+ is($object->get_last_message_param, "2.1", "round down double as uint16");
+
+ $myobject->ScalarUInt16(2.9);
+ is($object->get_last_message_signature, "s", "round up double as uint16");
+ is($object->get_last_message_param, "2.9", "round up double as uint16");
+
+ $myobject->ScalarUInt16(2.5);
+ is($object->get_last_message_signature, "s", "round up double threshold as uint16");
+ is($object->get_last_message_param, "2.5", "round up double threshold as uint16");
+
+
#### INT 32 tests
# Positive integers
@@ -249,6 +346,124 @@ TEST_MANUAL_TYPING: {
is($object->get_last_message_param, "5.234", "double as string");
+ #### INT 16 tests
+
+ # Positive integers
+ $myobject->ScalarInt16(dbus_int16("2"));
+ is($object->get_last_message_signature, "n", "string as int16");
+ is($object->get_last_message_param, 2, "string as int16");
+
+ $myobject->ScalarInt16(dbus_int16(2));
+ is($object->get_last_message_signature, "n", "int as int16");
+ is($object->get_last_message_param, 2, "int as int16");
+
+ $myobject->ScalarInt16(dbus_int16(2.0));
+ is($object->get_last_message_signature, "n", "double as int16");
+ is($object->get_last_message_param, 2, "double as int16");
+
+ # Negative integers
+ $myobject->ScalarInt16(dbus_int16("-2"));
+ is($object->get_last_message_signature, "n", "-ve string as int16");
+ is($object->get_last_message_param, -2, "-ve string as int16");
+
+ $myobject->ScalarInt16(dbus_int16(-2));
+ is($object->get_last_message_signature, "n", "-ve int as int16");
+ is($object->get_last_message_param, -2, "-ve int as int16");
+
+ $myobject->ScalarInt16(dbus_int16(-2.0));
+ is($object->get_last_message_signature, "n", "-ve double as int16");
+ is($object->get_last_message_param, -2, "-ve double as int16");
+
+ # Rounding of doubles
+ $myobject->ScalarInt16(dbus_int16(2.1));
+ is($object->get_last_message_signature, "n", "round down double as int16");
+ is($object->get_last_message_param, 2, "round down double as int16");
+
+ $myobject->ScalarInt16(dbus_int16(2.9));
+ is($object->get_last_message_signature, "n", "round up double as int16");
+ SKIP: {
+ skip "rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double as int16");
+ }
+ $myobject->ScalarInt16(dbus_int16(2.5));
+ is($object->get_last_message_signature, "n", "round up double threshold as int16");
+ SKIP: {
+ skip "rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double threshold as int16");
+ }
+
+ $myobject->ScalarInt16(dbus_int16(-2.1));
+ is($object->get_last_message_signature, "n", "-ve round up double as int16");
+ is($object->get_last_message_param, -2, "-ve round up double as int16");
+
+ $myobject->ScalarInt16(dbus_int16(-2.9));
+ is($object->get_last_message_signature, "n", "-ve round down double as int16");
+ SKIP: {
+ skip "rounding actually truncates", 1;
+ is($object->get_last_message_param, -3, "-ve round down double as int16");
+ }
+
+ $myobject->ScalarInt16(dbus_int16(-2.5));
+ is($object->get_last_message_signature, "n", "-ve round down double threshold as int16");
+ is($object->get_last_message_param, -2, "-ve round down double threshold as int16");
+
+
+ #### UINT 16 tests
+
+ # Positive integers
+ $myobject->ScalarUInt16(dbus_uint16("2"));
+ is($object->get_last_message_signature, "q", "string as uint16");
+ is($object->get_last_message_param, 2, "string as uint16");
+
+ $myobject->ScalarUInt16(dbus_uint16(2));
+ is($object->get_last_message_signature, "q", "int as uint16");
+ is($object->get_last_message_param, 2, "int as uint16");
+
+ $myobject->ScalarUInt16(dbus_uint16(2.0));
+ is($object->get_last_message_signature, "q", "double as uint16");
+ is($object->get_last_message_param, 2, "double as uint16");
+
+ # Negative integers
+ $myobject->ScalarUInt16(dbus_uint16("-2"));
+ is($object->get_last_message_signature, "q", "-ve string as uint16");
+ SKIP: {
+ skip "sign truncation is wrong", 1;
+ is($object->get_last_message_param, -2, "-ve string as uint16");
+ }
+
+ $myobject->ScalarUInt16(dbus_uint16(-2));
+ is($object->get_last_message_signature, "q", "-ve int as uint16");
+ SKIP: {
+ skip "sign truncation is wrong", 1;
+ is($object->get_last_message_param, -2, "-ve int as uint16");
+ }
+
+ $myobject->ScalarUInt16(dbus_uint16(-2.0));
+ is($object->get_last_message_signature, "q", "-ve double as uint16");
+ SKIP: {
+ skip "sign truncation is wrong", 1;
+ is($object->get_last_message_param, -2, "-ve double as uint16");
+ }
+
+ # Rounding of doubles
+ $myobject->ScalarUInt16(dbus_uint16(2.1));
+ is($object->get_last_message_signature, "q", "round down double as uint16");
+ is($object->get_last_message_param, 2, "round down double as uint16");
+
+ $myobject->ScalarUInt16(dbus_uint16(2.9));
+ is($object->get_last_message_signature, "q", "round up double as uint16");
+ SKIP: {
+ skip "rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double as uint16");
+ }
+
+ $myobject->ScalarUInt16(dbus_uint16(2.5));
+ is($object->get_last_message_signature, "q", "round up double threshold as uint16");
+ SKIP: {
+ skip "rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double threshold as uint16");
+ }
+
#### INT 32 tests
# Positive integers
@@ -489,6 +704,8 @@ TEST_INTROSPECT_TYPING: {
my $ins = Net::DBus::Binding::Introspector->new(object_path => $object->get_object_path);
$ins->add_method("ScalarString", ["string"], [], "org.example.MyObject");
+ $ins->add_method("ScalarInt16", ["int16"], [], "org.example.MyObject");
+ $ins->add_method("ScalarUInt16", ["uint16"], [], "org.example.MyObject");
$ins->add_method("ScalarInt32", ["int32"], [], "org.example.MyObject");
$ins->add_method("ScalarUInt32", ["uint32"], [], "org.example.MyObject");
$ins->add_method("ScalarDouble", ["double"], [], "org.example.MyObject");
@@ -512,6 +729,135 @@ TEST_INTROSPECT_TYPING: {
is($object->get_last_message_param, "5.234", "double as string");
+ #### INT 16 tests
+
+ # Positive integers
+ $myobject->ScalarInt16("2");
+ is($object->get_last_message_signature, "n", "string as int16");
+ is($object->get_last_message_param, 2, "string as int16");
+
+ $myobject->ScalarInt16(2);
+ is($object->get_last_message_signature, "n", "int as int16");
+ is($object->get_last_message_param, 2, "int as int16");
+
+ $myobject->ScalarInt16(2.0);
+ is($object->get_last_message_signature, "n", "double as int16");
+ is($object->get_last_message_param, 2, "double as int16");
+
+ # Negative integers
+ $myobject->ScalarInt16("-2");
+ is($object->get_last_message_signature, "n", "-ve string as int16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, "-2", "-ve string as int16");
+ }
+
+ $myobject->ScalarInt16(-2);
+ is($object->get_last_message_signature, "n", "-ve int as int16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, "-2", "-ve int as int16");
+ }
+
+ $myobject->ScalarInt16(-2.0);
+ is($object->get_last_message_signature, "n", "-ve double as int16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, "-2.0", "-ve double as int16");
+ }
+
+ # Rounding of doubles
+ $myobject->ScalarInt16(2.1);
+ is($object->get_last_message_signature, "n", "round down double as int16");
+ is($object->get_last_message_param, 2, "round down double as int16");
+
+ $myobject->ScalarInt16(2.9);
+ is($object->get_last_message_signature, "n", "round up double as int16");
+ SKIP: {
+ skip "double -> int rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double as int16");
+ }
+
+ $myobject->ScalarInt16(2.5);
+ is($object->get_last_message_signature, "n", "round up double threshold as int16");
+ SKIP: {
+ skip "double -> int rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double threshold as int16");
+ }
+
+ $myobject->ScalarInt16(-2.1);
+ is($object->get_last_message_signature, "n", "-ve round up double as int16");
+ is($object->get_last_message_param, -2, "-ve round up double as int16");
+
+ $myobject->ScalarInt16(-2.9);
+ is($object->get_last_message_signature, "n", "-ve round down double as int16");
+ SKIP: {
+ skip "double -> int rounding actually truncates", 1;
+ is($object->get_last_message_param, -3, "-ve round down double as int16");
+ }
+
+ $myobject->ScalarInt16(-2.5);
+ is($object->get_last_message_signature, "n", "-ve round down double threshold as int16");
+ is($object->get_last_message_param, -2, "-ve round down double threshold as int16");
+
+
+ #### UINT 16 tests
+
+ # Positive integers
+ $myobject->ScalarUInt16("2");
+ is($object->get_last_message_signature, "q", "string as uint16");
+ is($object->get_last_message_param, 2, "string as uint16");
+
+ $myobject->ScalarUInt16(2);
+ is($object->get_last_message_signature, "q", "int as uint16");
+ is($object->get_last_message_param, 2, "int as uint16");
+
+ $myobject->ScalarUInt16(2.0);
+ is($object->get_last_message_signature, "q", "double as uint16");
+ is($object->get_last_message_param, 2, "double as uint16");
+
+ # Negative integers
+ $myobject->ScalarUInt16("-2");
+ is($object->get_last_message_signature, "q", "-ve string as uint16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, -2, "-ve string as uint16");
+ }
+
+ $myobject->ScalarUInt16(-2);
+ is($object->get_last_message_signature, "q", "-ve int as uint16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, -2, "-ve int as uint16");
+ }
+
+ $myobject->ScalarUInt16(-2.0);
+ is($object->get_last_message_signature, "q", "-ve double as uint16");
+ SKIP: {
+ skip "sign truncation not checked", 1;
+ is($object->get_last_message_param, -2, "-ve double as uint16");
+ }
+
+
+ # Rounding of doubles
+ $myobject->ScalarUInt16(2.1);
+ is($object->get_last_message_signature, "q", "round down double as uint16");
+ is($object->get_last_message_param, 2, "round down double as uint16");
+
+ $myobject->ScalarUInt16(2.9);
+ is($object->get_last_message_signature, "q", "round up double as uint16");
+ SKIP: {
+ skip "double -> int rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double as uint16");
+ }
+
+ $myobject->ScalarUInt16(2.5);
+ is($object->get_last_message_signature, "q", "round up double threshold as uint16");
+ SKIP: {
+ skip "double -> int rounding actually truncates", 1;
+ is($object->get_last_message_param, 3, "round up double threshold as uint16");
+ }
+
#### INT 32 tests
# Positive integers
@@ -771,6 +1117,8 @@ sub setup {
my $otherobject = $robject->as_interface("org.example.OtherObject");
$object->seed_action("org.example.MyObject", "ScalarString", reply => { return => [] });
+ $object->seed_action("org.example.MyObject", "ScalarInt16", reply => { return => [] });
+ $object->seed_action("org.example.MyObject", "ScalarUInt16", reply => { return => [] });
$object->seed_action("org.example.MyObject", "ScalarInt32", reply => { return => [] });
$object->seed_action("org.example.MyObject", "ScalarUInt32", reply => { return => [] });
$object->seed_action("org.example.MyObject", "ScalarDouble", reply => { return => [] });
diff --git a/typemap b/typemap
index 7854335..8aba8f5 100644
--- a/typemap
+++ b/typemap
@@ -8,6 +8,8 @@ DBusTimeout* O_OBJECT_timeout
DBusMessageIter* O_OBJECT_messageiter
DBusBusType T_IV
dbus_bool_t T_BOOL
+dbus_int16_t T_IV
+dbus_uint16_t T_UV
dbus_int32_t T_IV
dbus_uint32_t T_UV
dbus_int64_t T_IV
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libnet-dbus-perl.git
More information about the Pkg-perl-cvs-commits
mailing list