Re: [perl #36130] chr(-1) should probably return undef

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

diff --git a/t/op/ref.t b/t/op/ref.t
index c0d86a6..53f3fac 100755 (executable)
--- a/t/op/ref.t
+++ b/t/op/ref.t
@@ -6,8 +6,9 @@ BEGIN {
 }
 
 require 'test.pl';
+use strict qw(refs subs);
 
-plan (74);
+plan (89);
 
 # Test glob operations.
 
@@ -36,12 +37,15 @@ $foo = "global";
 }
 is ($foo, 'global');
 
+{
+    no strict 'refs';
 # Test fake references.
 
-$baz = "valid";
-$bar = 'baz';
-$foo = 'bar';
-is ($$$foo, 'valid');
+    $baz = "valid";
+    $bar = 'baz';
+    $foo = 'bar';
+    is ($$$foo, 'valid');
+}
 
 # Test real references.
 
@@ -64,7 +68,10 @@ for $i (3,1,2,0) {
 print @a;
 print ${$ref[1]}[0];
 print @{$ref[2]}[0];
-print @{'d'};
+{
+    no strict 'refs';
+    print @{'d'};
+}
 curr_test($test+4);
 
 # Test references to references.
@@ -127,7 +134,7 @@ is (ref $refref, 'HASH');
 
 $anonhash = {};
 is (ref $anonhash, 'HASH');
-$anonhash2 = {FOO => BAR, ABC => XYZ,};
+$anonhash2 = {FOO => 'BAR', ABC => 'XYZ',};
 is (join('', sort values %$anonhash2), 'BARXYZ');
 
 # Test bless operator.
@@ -148,7 +155,7 @@ main::is (ref $object2,     'MYHASH');
 sub mymethod {
     local($THIS, @ARGS) = @_;
     die 'Got a "' . ref($THIS). '" instead of a MYHASH'
-       unless ref $THIS eq MYHASH;
+       unless ref $THIS eq 'MYHASH';
     main::is ($ARGS[0], "argument");
     main::is ($THIS->{FOO}, 'BAR');
 }
@@ -173,24 +180,24 @@ DESTROY {
 
 package OBJ;
 
-@ISA = (BASEOBJ);
+@ISA = ('BASEOBJ');
 
-$main'object = bless {FOO => foo, BAR => bar};
+$main'object = bless {FOO => 'foo', BAR => 'bar'};
 
 package main;
 
 # Test arrow-style method invocation.
 
-is ($object->doit("BAR"), bar);
+is ($object->doit("BAR"), 'bar');
 
 # Test indirect-object-style method invocation.
 
 $foo = doit $object "FOO";
-main::is ($foo, foo);
+main::is ($foo, 'foo');
 
 sub BASEOBJ'doit {
     local $ref = shift;
-    die "Not an OBJ" unless ref $ref eq OBJ;
+    die "Not an OBJ" unless ref $ref eq 'OBJ';
     $ref->{shift()};
 }
 
@@ -325,7 +332,7 @@ foreach my $lexical ('', 'my $a; ') {
   is ($result, $expect);
 }
 
-my $test = curr_test();
+$test = curr_test();
 sub x::DESTROY {print "ok ", $test + shift->[0], "\n"}
 { my $a1 = bless [3],"x";
   my $a2 = bless [2],"x";
@@ -371,6 +378,53 @@ like (runperl(
     stderr => 1
       ), qr/^(ok)+$/, 'STDOUT destructor');
 
+TODO: {
+    no strict 'refs';
+    $name8 = chr 163;
+    $name_utf8 = $name8 . chr 256;
+    chop $name_utf8;
+
+    is ($$name8, undef, 'Nothing before we start');
+    is ($$name_utf8, undef, 'Nothing before we start');
+    $$name8 = "Pound";
+    is ($$name8, "Pound", 'Accessing via 8 bit symref works');
+    local $TODO = "UTF8 mangled in symrefs";
+    is ($$name_utf8, "Pound", 'Accessing via UTF8 symref works');
+}
+
+TODO: {
+    no strict 'refs';
+    $name_utf8 = $name = chr 9787;
+    utf8::encode $name_utf8;
+
+    is (length $name, 1, "Name is 1 char");
+    is (length $name_utf8, 3, "UTF8 representation is 3 chars");
+
+    is ($$name, undef, 'Nothing before we start');
+    is ($$name_utf8, undef, 'Nothing before we start');
+    $$name = "Face";
+    is ($$name, "Face", 'Accessing via Unicode symref works');
+    local $TODO = "UTF8 mangled in symrefs";
+    is ($$name_utf8, undef,
+       'Accessing via the UTF8 byte sequence gives nothing');
+}
+
+TODO: {
+    no strict 'refs';
+    $name1 = "\0Chalk";
+    $name2 = "\0Cheese";
+
+    isnt ($name1, $name2, "They differ");
+
+    is ($$name1, undef, 'Nothing before we start');
+    is ($$name2, undef, 'Nothing before we start');
+    $$name2 = "Yummy";
+    is ($$name1, "Yummy", 'Accessing via the correct name works');
+    local $TODO = "NUL bytes truncate in symrefs";
+    is ($$name2, undef,
+       'Accessing via a different NUL-containing name gives nothing');
+}
+
 # Bit of a hack to make test.pl happy. There are 3 more tests after it leaves.
 $test = curr_test();
 curr_test($test + 3);