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 <berra...@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); -@EXPORT_OK = qw(dbus_int32 dbus_uint32 dbus_int64 dbus_uint64 +@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 _______________________________________________ Pkg-perl-cvs-commits mailing list Pkg-perl-cvs-commits@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits