GNOME.org
 

[perl-Glib-Object-Introspection] Change the namespace of one of the test libraries

commit e0dfa11e47070fd5a6ed2e63cb65527f0329d14a
Author: Torsten SchÃnfeld <kaffeetisch gmx de>
Date:   Sat Aug 20 20:01:04 2011 +0200

    Change the namespace of one of the test libraries

 t/00-basic-types.t    |   63 ++++++++++++++++++++--------------------
 t/arrays.t            |   76 ++++++++++++++++++++++++------------------------
 t/boxed.t             |   22 +++++++-------
 t/cairo-integration.t |   12 ++++----
 t/callbacks.t         |   20 ++++++------
 t/closures.t          |    4 +-
 t/constants.t         |    8 ++--
 t/enums.t             |    6 ++--
 t/hashes.t            |   22 +++++++-------
 t/inc/setup.pl        |    2 +-
 t/objects.t           |   38 ++++++++++++------------
 t/structs.t           |    4 +-
 t/values.t            |    4 +-
 13 files changed, 141 insertions(+), 140 deletions(-)
---
diff --git a/t/00-basic-types.t b/t/00-basic-types.t
index e5a35d3..6f056eb 100644
--- a/t/00-basic-types.t
+++ b/t/00-basic-types.t
@@ -10,56 +10,57 @@ use POSIX qw(FLT_MIN FLT_MAX DBL_MIN DBL_MAX);
 
 plan tests => 34;
 
-ok (test_boolean (1));
-ok (!test_boolean (0));
-is (test_int8 (-127), -127);
-is (test_uint8 (255), 255);
-is (test_int16 (-32767), -32767);
-is (test_uint16 (65535), 65535);
-is (test_int32 (-2147483647), -2147483647);
-is (test_uint32 (4294967295), 4294967295);
-is (test_int64 ('-9223372036854775807'), '-9223372036854775807');
-is (test_uint64 ('18446744073709551615'), '18446744073709551615');
-delta_ok (test_float (FLT_MIN), FLT_MIN);
-delta_ok (test_float (FLT_MAX), FLT_MAX);
-delta_ok (test_double (DBL_MIN), DBL_MIN);
-delta_ok (test_double (DBL_MAX), DBL_MAX);
+ok (Regress::test_boolean (1));
+ok (!Regress::test_boolean (0));
+is (Regress::test_int8 (-127), -127);
+is (Regress::test_uint8 (255), 255);
+is (Regress::test_int16 (-32767), -32767);
+is (Regress::test_uint16 (65535), 65535);
+is (Regress::test_int32 (-2147483647), -2147483647);
+is (Regress::test_uint32 (4294967295), 4294967295);
+is (Regress::test_int64 ('-9223372036854775807'), '-9223372036854775807');
+is (Regress::test_uint64 ('18446744073709551615'), '18446744073709551615');
+delta_ok (Regress::test_float (FLT_MIN), FLT_MIN);
+delta_ok (Regress::test_float (FLT_MAX), FLT_MAX);
+delta_ok (Regress::test_double (DBL_MIN), DBL_MIN);
+delta_ok (Regress::test_double (DBL_MAX), DBL_MAX);
 
-is (test_unichar ('â'), 'â');
+is (Regress::test_unichar ('â'), 'â');
 
 my $time = time ();
-is (test_timet ($time), $time);
+is (Regress::test_timet ($time), $time);
 
-is (test_gtype ('Glib::Object'), 'Glib::Object');
+is (Regress::test_gtype ('Glib::Object'), 'Glib::Object');
 TODO: {
   local $TODO = 'Is that how we want to handle unregistered GTypes?';
-  is (test_gtype ('GIRepository'),
+  is (Regress::test_gtype ('GIRepository'),
       'Glib::Object::_Unregistered::GIRepository');
 }
-is (test_gtype ('Inexistant'), undef);
+is (Regress::test_gtype ('Inexistant'), undef);
 
 my $expected_const_string = 'const â utf8';
 my $expected_nonconst_string = 'nonconst â utf8';
-is (test_utf8_const_return (), $expected_const_string);
-is (test_utf8_nonconst_return (), $expected_nonconst_string);
-test_utf8_const_in (test_utf8_const_return ());
-is (test_utf8_out (), $expected_nonconst_string);
-is (test_utf8_inout (test_utf8_const_return ()), test_utf8_nonconst_return ());
-test_utf8_null_in (undef);
-is (test_utf8_null_out (), undef);
+is (Regress::test_utf8_const_return (), $expected_const_string);
+is (Regress::test_utf8_nonconst_return (), $expected_nonconst_string);
+Regress::test_utf8_const_in (Regress::test_utf8_const_return ());
+is (Regress::test_utf8_out (), $expected_nonconst_string);
+is (Regress::test_utf8_inout (Regress::test_utf8_const_return ()),
+    Regress::test_utf8_nonconst_return ());
+Regress::test_utf8_null_in (undef);
+is (Regress::test_utf8_null_out (), undef);
 
-my $filenames = test_filename_return ();
+my $filenames = Regress::test_filename_return ();
 is (scalar @$filenames, 2);
 is ($filenames->[0], 'ÃÃÃ');
 is ($filenames->[1], '/etc/fstab');
 
-is (test_int_out_utf8 ('ÎÎÎè'), 4);
-my ($one, $two) = test_multi_double_args (my $pi = 3.1415);
+is (Regress::test_int_out_utf8 ('ÎÎÎè'), 4);
+my ($one, $two) = Regress::test_multi_double_args (my $pi = 3.1415);
 delta_ok ($one, 2*$pi);
 delta_ok ($two, 3*$pi);
-($one, $two) = test_utf8_out_out ();
+($one, $two) = Regress::test_utf8_out_out ();
 is ($one, 'first');
 is ($two, 'second');
-($one, $two) = test_utf8_out_nonconst_return ();
+($one, $two) = Regress::test_utf8_out_nonconst_return ();
 is ($one, 'first');
 is ($two, 'second');
diff --git a/t/arrays.t b/t/arrays.t
index 9cfe821..75bcde8 100644
--- a/t/arrays.t
+++ b/t/arrays.t
@@ -8,45 +8,45 @@ use utf8;
 
 plan tests => 29;
 
-ok (test_strv_in ([ '1', '2', '3' ]));
+ok (Regress::test_strv_in ([ '1', '2', '3' ]));
 
 my $int_array = [ 1, 2, 3 ];
-is (test_array_int_in ($int_array), 6);
-is_deeply (test_array_int_out (), [0, 1, 2, 3, 4]);
-is_deeply (test_array_int_inout ($int_array), [3, 4]);
-is (test_array_gint8_in ($int_array), 6);
-is (test_array_gint16_in ($int_array), 6);
-is (test_array_gint32_in ($int_array), 6);
-is (test_array_gint64_in ($int_array), 6);
-is (test_array_gtype_in ([ 'Glib::Object', 'Glib::Int64' ]), "[GObject,gint64,]");
-is (test_array_fixed_size_int_in ([ 1, 2, 3, 4, 5 ]), 15);
-is_deeply (test_array_fixed_size_int_out (), [ 0, 1, 2, 3, 4 ]);
-is_deeply (test_array_fixed_size_int_return (), [ 0, 1, 2, 3, 4 ]);
-is_deeply (test_strv_out_container (), [ '1', '2', '3' ]);
-is_deeply (test_strv_out (), [ 'thanks', 'for', 'all', 'the', 'fish' ]);
-is_deeply (test_strv_out_c (), [ 'thanks', 'for', 'all', 'the', 'fish' ]);
-is_deeply (test_strv_outarg (), [ '1', '2', '3' ]);
-
-is_deeply (test_array_int_full_out (), [0, 1, 2, 3, 4]);
-is_deeply (test_array_int_none_out (), [1, 2, 3, 4, 5]);
-test_array_int_null_in (undef);
-is (test_array_int_null_out, undef);
+is (Regress::test_array_int_in ($int_array), 6);
+is_deeply (Regress::test_array_int_out (), [0, 1, 2, 3, 4]);
+is_deeply (Regress::test_array_int_inout ($int_array), [3, 4]);
+is (Regress::test_array_gint8_in ($int_array), 6);
+is (Regress::test_array_gint16_in ($int_array), 6);
+is (Regress::test_array_gint32_in ($int_array), 6);
+is (Regress::test_array_gint64_in ($int_array), 6);
+is (Regress::test_array_gtype_in ([ 'Glib::Object', 'Glib::Int64' ]), "[GObject,gint64,]");
+is (Regress::test_array_fixed_size_int_in ([ 1, 2, 3, 4, 5 ]), 15);
+is_deeply (Regress::test_array_fixed_size_int_out (), [ 0, 1, 2, 3, 4 ]);
+is_deeply (Regress::test_array_fixed_size_int_return (), [ 0, 1, 2, 3, 4 ]);
+is_deeply (Regress::test_strv_out_container (), [ '1', '2', '3' ]);
+is_deeply (Regress::test_strv_out (), [ 'thanks', 'for', 'all', 'the', 'fish' ]);
+is_deeply (Regress::test_strv_out_c (), [ 'thanks', 'for', 'all', 'the', 'fish' ]);
+is_deeply (Regress::test_strv_outarg (), [ '1', '2', '3' ]);
+
+is_deeply (Regress::test_array_int_full_out (), [0, 1, 2, 3, 4]);
+is_deeply (Regress::test_array_int_none_out (), [1, 2, 3, 4, 5]);
+Regress::test_array_int_null_in (undef);
+is (Regress::test_array_int_null_out, undef);
 
 my $test_list = [1, 2, 3];
-is_deeply (test_glist_nothing_return (), $test_list);
-is_deeply (test_glist_nothing_return2 (), $test_list);
-is_deeply (test_glist_container_return (), $test_list);
-is_deeply (test_glist_everything_return (), $test_list);
-test_glist_nothing_in ($test_list);
-test_glist_nothing_in2 ($test_list);
-test_glist_null_in (undef);
-is (test_glist_null_out (), undef);
-
-is_deeply (test_gslist_nothing_return (), $test_list);
-is_deeply (test_gslist_nothing_return2 (), $test_list);
-is_deeply (test_gslist_container_return (), $test_list);
-is_deeply (test_gslist_everything_return (), $test_list);
-test_gslist_nothing_in ($test_list);
-test_gslist_nothing_in2 ($test_list);
-test_gslist_null_in (undef);
-is (test_gslist_null_out (), undef);
+is_deeply (Regress::test_glist_nothing_return (), $test_list);
+is_deeply (Regress::test_glist_nothing_return2 (), $test_list);
+is_deeply (Regress::test_glist_container_return (), $test_list);
+is_deeply (Regress::test_glist_everything_return (), $test_list);
+Regress::test_glist_nothing_in ($test_list);
+Regress::test_glist_nothing_in2 ($test_list);
+Regress::test_glist_null_in (undef);
+is (Regress::test_glist_null_out (), undef);
+
+is_deeply (Regress::test_gslist_nothing_return (), $test_list);
+is_deeply (Regress::test_gslist_nothing_return2 (), $test_list);
+is_deeply (Regress::test_gslist_container_return (), $test_list);
+is_deeply (Regress::test_gslist_everything_return (), $test_list);
+Regress::test_gslist_nothing_in ($test_list);
+Regress::test_gslist_nothing_in2 ($test_list);
+Regress::test_gslist_null_in (undef);
+is (Regress::test_gslist_null_out (), undef);
diff --git a/t/boxed.t b/t/boxed.t
index 5b1fb1d..ba9d644 100644
--- a/t/boxed.t
+++ b/t/boxed.t
@@ -58,8 +58,8 @@ plan tests => 41;
 # --------------------------------------------------------------------------- #
 
 {
-  my $boxed = TestSimpleBoxedA::const_return ();
-  isa_ok ($boxed, 'TestSimpleBoxedA');
+  my $boxed = Regress::TestSimpleBoxedA::const_return ();
+  isa_ok ($boxed, 'Regress::TestSimpleBoxedA');
   isa_ok ($boxed, 'Glib::Boxed');
   my $copy = $boxed->copy;
   ok ($boxed->equals ($copy));
@@ -70,11 +70,11 @@ plan tests => 41;
 }
 
 {
-  my $boxed = TestBoxed->new;
-  isa_ok ($boxed, 'TestBoxed');
+  my $boxed = Regress::TestBoxed->new;
+  isa_ok ($boxed, 'Regress::TestBoxed');
   isa_ok ($boxed, 'Glib::Boxed');
   my $copy = $boxed->copy;
-  isa_ok ($boxed, 'TestBoxed');
+  isa_ok ($boxed, 'Regress::TestBoxed');
   isa_ok ($boxed, 'Glib::Boxed');
   ok ($boxed->equals ($copy));
   weaken $boxed;
@@ -82,20 +82,20 @@ plan tests => 41;
   weaken $copy;
   is ($copy, undef);
 
-  $boxed = TestBoxed->new_alternative_constructor1 (23);
-  isa_ok ($boxed, 'TestBoxed');
+  $boxed = Regress::TestBoxed->new_alternative_constructor1 (23);
+  isa_ok ($boxed, 'Regress::TestBoxed');
   isa_ok ($boxed, 'Glib::Boxed');
   weaken $boxed;
   is ($boxed, undef);
 
-  $boxed = TestBoxed->new_alternative_constructor2 (23, 42);
-  isa_ok ($boxed, 'TestBoxed');
+  $boxed = Regress::TestBoxed->new_alternative_constructor2 (23, 42);
+  isa_ok ($boxed, 'Regress::TestBoxed');
   isa_ok ($boxed, 'Glib::Boxed');
   weaken $boxed;
   is ($boxed, undef);
 
-  $boxed = TestBoxed->new_alternative_constructor3 ("perl");
-  isa_ok ($boxed, 'TestBoxed');
+  $boxed = Regress::TestBoxed->new_alternative_constructor3 ("perl");
+  isa_ok ($boxed, 'Regress::TestBoxed');
   isa_ok ($boxed, 'Glib::Boxed');
   weaken $boxed;
   is ($boxed, undef);
diff --git a/t/cairo-integration.t b/t/cairo-integration.t
index a91a574..2395aed 100644
--- a/t/cairo-integration.t
+++ b/t/cairo-integration.t
@@ -9,21 +9,21 @@ my $have_cairo_gobject = eval 'use Cairo::GObject; 1';
 
 plan $have_cairo_gobject ? (tests => 8) : (skip_all => 'Need Cairo::GObject');
 
-my $cr = test_cairo_context_full_return ();
+my $cr = Regress::test_cairo_context_full_return ();
 isa_ok ($cr, 'Cairo::Context');
 is ($cr->status, 'success');
-test_cairo_context_none_in ($cr);
+Regress::test_cairo_context_none_in ($cr);
 
-my $surf = test_cairo_surface_none_return ();
+my $surf = Regress::test_cairo_surface_none_return ();
 isa_ok ($surf, 'Cairo::Surface');
 is ($surf->status, 'success');
 
-$surf = test_cairo_surface_full_return ();
+$surf = Regress::test_cairo_surface_full_return ();
 isa_ok ($surf, 'Cairo::Surface');
 is ($surf->status, 'success');
 
-test_cairo_surface_none_in ($surf);
+Regress::test_cairo_surface_none_in ($surf);
 
-$surf = test_cairo_surface_full_out ();
+$surf = Regress::test_cairo_surface_full_out ();
 isa_ok ($surf, 'Cairo::Surface');
 is ($surf->status, 'success');
diff --git a/t/callbacks.t b/t/callbacks.t
index 0a9f8cd..c66106d 100644
--- a/t/callbacks.t
+++ b/t/callbacks.t
@@ -11,16 +11,16 @@ my $data = 42;
 my $result = 23;
 my $callback  = sub { is shift, $data; return $result; };
 
-is (test_callback_user_data ($callback, $data), $result);
+is (Regress::test_callback_user_data ($callback, $data), $result);
 
-is (test_callback_destroy_notify ($callback, $data), $result);
-is (test_callback_destroy_notify ($callback, $data), $result);
-is (test_callback_thaw_notifications (), 46);
+is (Regress::test_callback_destroy_notify ($callback, $data), $result);
+is (Regress::test_callback_destroy_notify ($callback, $data), $result);
+is (Regress::test_callback_thaw_notifications (), 46);
 
-test_callback_async ($callback, $data);
-test_callback_async ($callback, $data);
-is (test_callback_thaw_async (), $result);
+Regress::test_callback_async ($callback, $data);
+Regress::test_callback_async ($callback, $data);
+is (Regress::test_callback_thaw_async (), $result);
 
-my $obj = TestObj->new_callback ($callback, $data);
-isa_ok ($obj, 'TestObj');
-is (test_callback_thaw_notifications (), 23);
+my $obj = Regress::TestObj->new_callback ($callback, $data);
+isa_ok ($obj, 'Regress::TestObj');
+is (Regress::test_callback_thaw_notifications (), 23);
diff --git a/t/closures.t b/t/closures.t
index b04e714..75957fd 100644
--- a/t/closures.t
+++ b/t/closures.t
@@ -9,6 +9,6 @@ plan tests => 3;
 
 TODO: {
   local $TODO = 'User cannot supply user data';
-  is (test_closure (sub { return 23; }), 23);
-  is (test_closure_one_arg (sub { is (shift, 42); return 23; }, 42), 23);
+  is (Regress::test_closure (sub { return 23; }), 23);
+  is (Regress::test_closure_one_arg (sub { is (shift, 42); return 23; }, 42), 23);
 }
diff --git a/t/constants.t b/t/constants.t
index 44f91ee..d4a356f 100644
--- a/t/constants.t
+++ b/t/constants.t
@@ -7,7 +7,7 @@ use warnings;
 
 plan tests => 4;
 
-is (INT_CONSTANT, 4422);
-delta_ok (DOUBLE_CONSTANT, 44.22);
-is (STRING_CONSTANT, "Some String");
-is (Mixed_Case_Constant, 4423);
+is (Regress::INT_CONSTANT, 4422);
+delta_ok (Regress::DOUBLE_CONSTANT, 44.22);
+is (Regress::STRING_CONSTANT, "Some String");
+is (Regress::Mixed_Case_Constant, 4423);
diff --git a/t/enums.t b/t/enums.t
index 0ad73e9..28fe6f8 100644
--- a/t/enums.t
+++ b/t/enums.t
@@ -7,6 +7,6 @@ use warnings;
 
 plan tests => 3;
 
-is (test_enum_param ('value1'), 'value1');
-is (test_unsigned_enum_param ('value2'), 'value2');
-is (global_get_flags_out (), ['flag1', 'flag3']);
+is (Regress::test_enum_param ('value1'), 'value1');
+is (Regress::test_unsigned_enum_param ('value2'), 'value2');
+is (Regress::global_get_flags_out (), ['flag1', 'flag3']);
diff --git a/t/hashes.t b/t/hashes.t
index 5d60d62..3084341 100644
--- a/t/hashes.t
+++ b/t/hashes.t
@@ -8,14 +8,14 @@ use utf8;
 
 plan tests => 8;
 
-is(test_ghash_null_return(), undef);
-is_deeply(test_ghash_nothing_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
-is_deeply(test_ghash_nothing_return2(), { foo => 'bar', baz => 'bat', qux => 'quux' });
-is_deeply(test_ghash_container_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
-is_deeply(test_ghash_everything_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
-test_ghash_null_in(undef);
-is(test_ghash_null_out(), undef);
-test_ghash_nothing_in({ foo => 'bar', baz => 'bat', qux => 'quux' });
-test_ghash_nothing_in2({ foo => 'bar', baz => 'bat', qux => 'quux' });
-is_deeply(test_ghash_nested_everything_return(), { wibble => { foo => 'bar', baz => 'bat', qux => 'quux', }, });
-is_deeply(test_ghash_nested_everything_return2(), { wibble => { foo => 'bar', baz => 'bat', qux => 'quux', }, });
+is(Regress::test_ghash_null_return(), undef);
+is_deeply(Regress::test_ghash_nothing_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
+is_deeply(Regress::test_ghash_nothing_return2(), { foo => 'bar', baz => 'bat', qux => 'quux' });
+is_deeply(Regress::test_ghash_container_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
+is_deeply(Regress::test_ghash_everything_return(), { foo => 'bar', baz => 'bat', qux => 'quux' });
+Regress::test_ghash_null_in(undef);
+is(Regress::test_ghash_null_out(), undef);
+Regress::test_ghash_nothing_in({ foo => 'bar', baz => 'bat', qux => 'quux' });
+Regress::test_ghash_nothing_in2({ foo => 'bar', baz => 'bat', qux => 'quux' });
+is_deeply(Regress::test_ghash_nested_everything_return(), { wibble => { foo => 'bar', baz => 'bat', qux => 'quux', }, });
+is_deeply(Regress::test_ghash_nested_everything_return2(), { wibble => { foo => 'bar', baz => 'bat', qux => 'quux', }, });
diff --git a/t/inc/setup.pl b/t/inc/setup.pl
index 7e59113..583666e 100644
--- a/t/inc/setup.pl
+++ b/t/inc/setup.pl
@@ -14,7 +14,7 @@ unless (defined $ENV{LD_LIBRARY_PATH} &&
 Glib::Object::Introspection->setup(
   basename => 'Regress',
   version => '1.0',
-  package => 'main',
+  package => 'Regress',
   search_path => 'build');
 
 Glib::Object::Introspection->setup(
diff --git a/t/objects.t b/t/objects.t
index 304300f..e88315f 100644
--- a/t/objects.t
+++ b/t/objects.t
@@ -8,24 +8,24 @@ use Scalar::Util qw/weaken/;
 
 plan tests => 41;
 
-my $obj = TestObj->constructor;
-isa_ok ($obj, 'TestObj');
+my $obj = Regress::TestObj->constructor;
+isa_ok ($obj, 'Regress::TestObj');
 isa_ok ($obj, 'Glib::Object');
 
-$obj = TestObj->new ($obj);
-isa_ok ($obj, 'TestObj');
+$obj = Regress::TestObj->new ($obj);
+isa_ok ($obj, 'Regress::TestObj');
 isa_ok ($obj, 'Glib::Object');
 
 weaken $obj;
 is ($obj, undef);
 
-$obj = TestObj->new_from_file ($0);
-isa_ok ($obj, 'TestObj');
+$obj = Regress::TestObj->new_from_file ($0);
+isa_ok ($obj, 'Regress::TestObj');
 isa_ok ($obj, 'Glib::Object');
 
-$obj->set_bare (TestObj->constructor);
+$obj->set_bare (Regress::TestObj->constructor);
 is ($obj->instance_method, -1);
-is (TestObj::static_method (23), 23);
+is (Regress::TestObj::static_method (23), 23);
 $obj->forced_method;
 
 my ($y, $z, $q) = $obj->torture_signature_0 (23, 'perl', 42);
@@ -67,30 +67,30 @@ like ($@, qr/odd/);
 
 is ($obj->do_matrix ('perl'), 42);
 
-func_obj_null_in ($obj);
-func_obj_null_in (undef);
-is (TestObj::null_out (), undef);
+Regress::func_obj_null_in ($obj);
+Regress::func_obj_null_in (undef);
+is (Regress::TestObj::null_out (), undef);
 
 # inheritance
-my $sub = TestSubObj->new;
-isa_ok ($sub, 'TestSubObj');
-isa_ok ($sub, 'TestObj');
+my $sub = Regress::TestSubObj->new;
+isa_ok ($sub, 'Regress::TestSubObj');
+isa_ok ($sub, 'Regress::TestObj');
 isa_ok ($sub, 'Glib::Object');
 $sub->unset_bare;
 is ($sub->instance_method, 0);
 
 # unusual prefix
-my $wi = TestWi8021x->new;
-isa_ok ($wi, 'TestWi8021x');
+my $wi = Regress::TestWi8021x->new;
+isa_ok ($wi, 'Regress::TestWi8021x');
 isa_ok ($wi, 'Glib::Object');
 $wi->set_testbool (1);
 ok ($wi->get_testbool);
-is (TestWi8021x::static_method (23), 46);
+is (Regress::TestWi8021x::static_method (23), 46);
 
 # floating objects
 SKIP: {
-  my $fl = TestFloating->new;
-  isa_ok ($fl, 'TestFloating');
+  my $fl = Regress::TestFloating->new;
+  isa_ok ($fl, 'Regress::TestFloating');
   isa_ok ($fl, 'Glib::InitiallyUnowned');
   isa_ok ($fl, 'Glib::Object');
 
diff --git a/t/structs.t b/t/structs.t
index ccdebb1..1845af7 100644
--- a/t/structs.t
+++ b/t/structs.t
@@ -29,7 +29,7 @@ plan tests => 6;
 {
   my $expected_struct = {
     some_int => 23, some_int8 => 42, some_double => 11, some_enum => 'value1'};
-  is_deeply (TestStructA::clone ($expected_struct), $expected_struct);
+  is_deeply (Regress::TestStructA::clone ($expected_struct), $expected_struct);
 }
 
 {
@@ -38,5 +38,5 @@ plan tests => 6;
     nested_a => {
       some_int => 23, some_int8 => 42,
       some_double => 11, some_enum => 'value1'}};
-  is_deeply (TestStructB::clone ($expected_struct), $expected_struct);
+  is_deeply (Regress::TestStructB::clone ($expected_struct), $expected_struct);
 }
diff --git a/t/values.t b/t/values.t
index 3baad8e..36b813f 100644
--- a/t/values.t
+++ b/t/values.t
@@ -9,6 +9,6 @@ plan tests => 2;
 
 SKIP: {
   skip 'SV â GValue not implemented', 1;
-  is (test_int_value_arg (23), 23);
+  is (Regress::test_int_value_arg (23), 23);
 }
-is (test_value_return (23), 23);
+is (Regress::test_value_return (23), 23);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]