Use minimal @INC in tests, most of the time just '../lib',

[p5sagit/p5-mst-13.2.git] / t / op / method.t

diff --git a/t/op/method.t b/t/op/method.t
index 21d7c8f..be4df75 100755 (executable)
--- a/t/op/method.t
+++ b/t/op/method.t
@@ -4,7 +4,12 @@
 # test method calls and autoloading.
 #
 
-print "1..20\n";
+BEGIN {
+    chdir 't' if -d 't';
+    @INC = '../lib';
+}
+
+print "1..53\n";
 
 @A::ISA = 'B';
 @B::ISA = 'C';
@@ -19,12 +24,49 @@ sub test {
   print "ok ", ++$cnt, "\n"
 }
 
+# First, some basic checks of method-calling syntax:
+$obj = bless [], "Pack";
+sub Pack::method { shift; join(",", "method", @_) }
+$mname = "method";
+
+test(Pack->method("a","b","c"), "method,a,b,c");
+test(Pack->$mname("a","b","c"), "method,a,b,c");
+test(method Pack ("a","b","c"), "method,a,b,c");
+test((method Pack "a","b","c"), "method,a,b,c");
+
+test(Pack->method(), "method");
+test(Pack->$mname(), "method");
+test(method Pack (), "method");
+test(Pack->method, "method");
+test(Pack->$mname, "method");
+test(method Pack, "method");
+
+test($obj->method("a","b","c"), "method,a,b,c");
+test($obj->$mname("a","b","c"), "method,a,b,c");
+test((method $obj ("a","b","c")), "method,a,b,c");
+test((method $obj "a","b","c"), "method,a,b,c");
+
+test($obj->method(), "method");
+test($obj->$mname(), "method");
+test((method $obj ()), "method");
+test($obj->method, "method");
+test($obj->$mname, "method");
+test(method $obj, "method");
+
 test( A->d, "C::d");           # Update hash table;
 
 *B::d = \&D::d;                        # Import now.
 test (A->d, "D::d");           # Update hash table;
 
 {
+    local @A::ISA = qw(C);     # Update hash table with split() assignment
+    test (A->d, "C::d");
+    $#A::ISA = -1;
+    test (eval { A->d } || "fail", "fail");
+}
+test (A->d, "D::d");
+
+{
     local *B::d;
     eval 'sub B::d {"B::d1"}'; # Import now.
     test (A->d, "B::d1");      # Update hash table;
@@ -58,6 +100,12 @@ test (A->d, "B::d4");               # Update hash table;
 delete $B::{d};                        # Should work without any help too
 test (A->d, "C::d");
 
+{
+    local *C::d;
+    test (eval { A->d } || "nope", "nope");
+}
+test (A->d, "C::d");
+
 *A::x = *A::d;                 # See if cache incorrectly follows synonyms
 A->d;
 test (eval { A->x } || "nope", "nope");
@@ -109,3 +157,31 @@ test(Y->f(), "B: In Y::f, 3");     # Which sticks
 
 test(A->eee(), "new B: In A::eee, 4"); # We get a correct $autoload
 test(A->eee(), "new B: In A::eee, 4"); # Which sticks
+
+# this test added due to bug discovery
+test(defined(@{"unknown_package::ISA"}) ? "defined" : "undefined", "undefined");
+
+# test that failed subroutine calls don't affect method calls
+{
+    package A1;
+    sub foo { "foo" }
+    package A2;
+    @ISA = 'A1';
+    package main;
+    test(A2->foo(), "foo");
+    test(do { eval 'A2::foo()'; $@ ? 1 : 0}, 1);
+    test(A2->foo(), "foo");
+}
+
+{
+    test(do { use Config; eval 'Config->foo()';
+             $@ =~ /^\QCan't locate object method "foo" via package "Config" at/ ? 1 : $@}, 1);
+    test(do { use Config; eval '$d = bless {}, "Config"; $d->foo()';
+             $@ =~ /^\QCan't locate object method "foo" via package "Config" at/ ? 1 : $@}, 1);
+}
+
+test(do { eval 'E->foo()';
+         $@ =~ /^\QCan't locate object method "foo" via package "E" (perhaps / ? 1 : $@}, 1);
+test(do { eval '$e = bless {}, "E"; $e->foo()';
+         $@ =~ /^\QCan't locate object method "foo" via package "E" (perhaps / ? 1 : $@}, 1);
+