

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: is_deeply_fail.t</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>#!/usr/bin/perl -w

BEGIN {
    if( $ENV{PERL_CORE} ) {
        chdir 't';
        @INC = ('../lib', 'lib');
    }
    else {
        unshift @INC, 't/lib';
    }
}

use strict;

use Test::Builder;
require Test::Simple::Catch;
my($out, $err) = Test::Simple::Catch::caught();
Test::Builder-&gt;new-&gt;no_header(1);
Test::Builder-&gt;new-&gt;no_ending(1);
local $ENV{HARNESS_ACTIVE} = 0;


# Can't use Test.pm, that's a 5.005 thing.
package main;


my $TB = Test::Builder-&gt;create;
$TB-&gt;plan(tests =&gt; 100);

# Utility testing functions.
sub ok ($;$) {
    return $TB-&gt;ok(@_);
}

sub is ($$;$) {
    my($this, $that, $name) = @_;

    my $ok = $TB-&gt;is_eq($$this, $that, $name);

    $$this = '';

    return $ok;
}

sub like ($$;$) {
    my($this, $regex, $name) = @_;
    $regex = &quot;/$regex/&quot; if !ref $regex and $regex !~ m{^/.*/$}s;

    my $ok = $TB-&gt;like($$this, $regex, $name);

    $$this = '';

    return $ok;
}


require Test::More;
Test::More-&gt;import(tests =&gt; 11, import =&gt; ['is_deeply']);

my $Filename = quotemeta $0;

#line 68
ok !is_deeply('foo', 'bar', 'plain strings');
is( $out, &quot;not ok 1 - plain strings\n&quot;,     'plain strings' );
is( $err, &lt;&lt;ERR,                            '    right diagnostic' );
#   Failed test 'plain strings'
#   at $0 line 68.
#          got: 'foo'
#     expected: 'bar'
ERR


#line 78
ok !is_deeply({}, [], 'different types');
is( $out, &quot;not ok 2 - different types\n&quot;,   'different types' );
like( $err, &lt;&lt;ERR,                          '   right diagnostic' );
#   Failed test 'different types'
#   at $Filename line 78.
#     Structures begin differing at:
#          \\\$got = HASH\\(0x[0-9a-f]+\\)
#     \\\$expected = ARRAY\\(0x[0-9a-f]+\\)
ERR

#line 88
ok !is_deeply({ this =&gt; 42 }, { this =&gt; 43 }, 'hashes with different values');
is( $out, &quot;not ok 3 - hashes with different values\n&quot;, 
                                        'hashes with different values' );
is( $err, &lt;&lt;ERR,                        '   right diagnostic' );
#   Failed test 'hashes with different values'
#   at $0 line 88.
#     Structures begin differing at:
#          \$got-&gt;{this} = '42'
#     \$expected-&gt;{this} = '43'
ERR

#line 99
ok !is_deeply({ that =&gt; 42 }, { this =&gt; 42 }, 'hashes with different keys');
is( $out, &quot;not ok 4 - hashes with different keys\n&quot;,
                                        'hashes with different keys' );
is( $err, &lt;&lt;ERR,                        '    right diagnostic' );
#   Failed test 'hashes with different keys'
#   at $0 line 99.
#     Structures begin differing at:
#          \$got-&gt;{this} = Does not exist
#     \$expected-&gt;{this} = '42'
ERR

#line 110
ok !is_deeply([1..9], [1..10],    'arrays of different length');
is( $out, &quot;not ok 5 - arrays of different length\n&quot;,
                                        'arrays of different length' );
is( $err, &lt;&lt;ERR,                        '    right diagnostic' );
#   Failed test 'arrays of different length'
#   at $0 line 110.
#     Structures begin differing at:
#          \$got-&gt;[9] = Does not exist
#     \$expected-&gt;[9] = '10'
ERR

#line 121
ok !is_deeply([undef, undef], [undef], 'arrays of undefs' );
is( $out, &quot;not ok 6 - arrays of undefs\n&quot;,  'arrays of undefs' );
is( $err, &lt;&lt;ERR,                            '    right diagnostic' );
#   Failed test 'arrays of undefs'
#   at $0 line 121.
#     Structures begin differing at:
#          \$got-&gt;[1] = undef
#     \$expected-&gt;[1] = Does not exist
ERR

#line 131
ok !is_deeply({ foo =&gt; undef }, {},    'hashes of undefs' );
is( $out, &quot;not ok 7 - hashes of undefs\n&quot;,  'hashes of undefs' );
is( $err, &lt;&lt;ERR,                            '    right diagnostic' );
#   Failed test 'hashes of undefs'
#   at $0 line 131.
#     Structures begin differing at:
#          \$got-&gt;{foo} = undef
#     \$expected-&gt;{foo} = Does not exist
ERR

#line 141
ok !is_deeply(\42, \23,   'scalar refs');
is( $out, &quot;not ok 8 - scalar refs\n&quot;,   'scalar refs' );
is( $err, &lt;&lt;ERR,                        '    right diagnostic' );
#   Failed test 'scalar refs'
#   at $0 line 141.
#     Structures begin differing at:
#     \${     \$got} = '42'
#     \${\$expected} = '23'
ERR

#line 151
ok !is_deeply([], \23,    'mixed scalar and array refs');
is( $out, &quot;not ok 9 - mixed scalar and array refs\n&quot;,
                                        'mixed scalar and array refs' );
like( $err, &lt;&lt;ERR,                      '    right diagnostic' );
#   Failed test 'mixed scalar and array refs'
#   at $Filename line 151.
#     Structures begin differing at:
#          \\\$got = ARRAY\\(0x[0-9a-f]+\\)
#     \\\$expected = SCALAR\\(0x[0-9a-f]+\\)
ERR


my($a1, $a2, $a3);
$a1 = \$a2;  $a2 = \$a3;
$a3 = 42;

my($b1, $b2, $b3);
$b1 = \$b2;  $b2 = \$b3;
$b3 = 23;

#line 173
ok !is_deeply($a1, $b1, 'deep scalar refs');
is( $out, &quot;not ok 10 - deep scalar refs\n&quot;,     'deep scalar refs' );
is( $err, &lt;&lt;ERR,                              '    right diagnostic' );
#   Failed test 'deep scalar refs'
#   at $0 line 173.
#     Structures begin differing at:
#     \${\${     \$got}} = '42'
#     \${\${\$expected}} = '23'
ERR

# I don't know how to properly display this structure.
# $a2 = { foo =&gt; \$a3 };
# $b2 = { foo =&gt; \$b3 };
# is_deeply([$a1], [$b1], 'deep mixed scalar refs');

my $foo = {
           this =&gt; [1..10],
           that =&gt; { up =&gt; &quot;down&quot;, left =&gt; &quot;right&quot; },
          };

my $bar = {
           this =&gt; [1..10],
           that =&gt; { up =&gt; &quot;down&quot;, left =&gt; &quot;right&quot;, foo =&gt; 42 },
          };

#line 198
ok !is_deeply( $foo, $bar, 'deep structures' );
ok( @Test::More::Data_Stack == 0, '@Data_Stack not holding onto things' );
is( $out, &quot;not ok 11 - deep structures\n&quot;,  'deep structures' );
is( $err, &lt;&lt;ERR,                            '    right diagnostic' );
#   Failed test 'deep structures'
#   at $0 line 198.
#     Structures begin differing at:
#          \$got-&gt;{that}{foo} = Does not exist
#     \$expected-&gt;{that}{foo} = '42'
ERR


#line 221
my @tests = ([],
             [qw(42)],
             [qw(42 23), qw(42 23)]
            );

foreach my $test (@tests) {
    my $num_args = @$test;

    my $warning;
    local $SIG{__WARN__} = sub { $warning .= join '', @_; };
    ok !is_deeply(@$test);

    like \$warning, 
         &quot;/^is_deeply\\(\\) takes two or three args, you gave $num_args\.\n/&quot;;
}


#line 240
# [rt.cpan.org 6837]
ok !is_deeply([{Foo =&gt; undef}],[{Foo =&gt; &quot;&quot;}]), 'undef != &quot;&quot;';
ok( @Test::More::Data_Stack == 0, '@Data_Stack not holding onto things' );


#line 258
# [rt.cpan.org 7031]
my $a = [];
ok !is_deeply($a, $a.''),       &quot;don't compare refs like strings&quot;;
ok !is_deeply([$a], [$a.'']),   &quot;  even deep inside&quot;;


#line 265
# [rt.cpan.org 7030]
ok !is_deeply( {}, {key =&gt; []} ),  '[] could match non-existent values';
ok !is_deeply( [], [[]] );


#line 273
$$err = $$out = '';
ok !is_deeply( [\'a', 'b'], [\'a', 'c'] );
is( $out, &quot;not ok 20\n&quot;,  'scalar refs in an array' );
is( $err, &lt;&lt;ERR,        '    right diagnostic' );
#   Failed test at $0 line 274.
#     Structures begin differing at:
#          \$got-&gt;[1] = 'b'
#     \$expected-&gt;[1] = 'c'
ERR


#line 285
my $ref = \23;
ok !is_deeply( 23, $ref );
is( $out, &quot;not ok 21\n&quot;, 'scalar vs ref' );
is( $err, &lt;&lt;ERR,        '  right diagnostic');
#   Failed test at $0 line 286.
#     Structures begin differing at:
#          \$got = '23'
#     \$expected = $ref
ERR

#line 296
ok !is_deeply( $ref, 23 );
is( $out, &quot;not ok 22\n&quot;, 'ref vs scalar' );
is( $err, &lt;&lt;ERR,        '  right diagnostic');
#   Failed test at $0 line 296.
#     Structures begin differing at:
#          \$got = $ref
#     \$expected = '23'
ERR

#line 306
ok !is_deeply( undef, [] );
is( $out, &quot;not ok 23\n&quot;, 'is_deeply and undef [RT 9441]' );
like( $err, &lt;&lt;ERR,	 '  right diagnostic' );
#   Failed test at $Filename line 306\\.
#     Structures begin differing at:
#          \\\$got = undef
#     \\\$expected = ARRAY\\(0x[0-9a-f]+\\)
ERR


# rt.cpan.org 8865
{
    my $array = [];
    my $hash  = {};

#line 321
    ok !is_deeply( $array, $hash );
    is( $out, &quot;not ok 24\n&quot;, 'is_deeply and different reference types' );
    is( $err, &lt;&lt;ERR, 	     '  right diagnostic' );
#   Failed test at $0 line 321.
#     Structures begin differing at:
#          \$got = $array
#     \$expected = $hash
ERR

#line 332
    ok !is_deeply( [$array], [$hash] );
    is( $out, &quot;not ok 25\n&quot;, 'nested different ref types' );
    is( $err, &lt;&lt;ERR,	     '  right diagnostic' );
#   Failed test at $0 line 332.
#     Structures begin differing at:
#          \$got-&gt;[0] = $array
#     \$expected-&gt;[0] = $hash
ERR


    # Overloaded object tests
    {
	my $foo = bless [], &quot;Foo&quot;;
	my $bar = bless {}, &quot;Bar&quot;;

	{
	    package Bar;
	    &quot;overload&quot;-&gt;import(q[&quot;&quot;] =&gt; sub { &quot;wibble&quot; });
	}

#line 353
	ok !is_deeply( [$foo], [$bar] );
	is( $out, &quot;not ok 26\n&quot;, 'string overloaded refs respected in diag' );
	is( $err, &lt;&lt;ERR,	     '  right diagnostic' );
#   Failed test at $0 line 353.
#     Structures begin differing at:
#          \$got-&gt;[0] = $foo
#     \$expected-&gt;[0] = 'wibble'
ERR

    }
}


# rt.cpan.org 14746
{
# line 349
    ok !is_deeply( sub {&quot;foo&quot;}, sub {&quot;bar&quot;} ), 'function refs';
    is( $out, &quot;not ok 27\n&quot; );
    like( $err, &lt;&lt;ERR,	     '  right diagnostic' );
#   Failed test at $Filename line 349.
#     Structures begin differing at:
#          \\\$got = CODE\\(0x[0-9a-f]+\\)
#     \\\$expected = CODE\\(0x[0-9a-f]+\\)
ERR


    use Symbol;
    my $glob1 = gensym;
    my $glob2 = gensym;

#line 357
    ok !is_deeply( $glob1, $glob2 ), 'typeglobs';
    is( $out, &quot;not ok 28\n&quot; );
    like( $err, &lt;&lt;ERR,	     '  right diagnostic' );
#   Failed test at $Filename line 357.
#     Structures begin differing at:
#          \\\$got = GLOB\\(0x[0-9a-f]+\\)
#     \\\$expected = GLOB\\(0x[0-9a-f]+\\)
ERR

}


# rt.cpan.org 53469
{

    # Accept both old and new-style stringification
    my $modifiers = (qr/foobar/ =~ /\Q(?^/) ? '^' : '-xism';
#line 380
    ok !is_deeply( qr/a/, qr/b/, &quot;different regexes&quot; );
    is( $out, &quot;not ok 29 - different regexes\n&quot; );
    is( $err, &lt;&lt;ERR,          '  right diagnostic' );
#   Failed test 'different regexes'
#   at $0 line 380.
#     Structures begin differing at:
#          \$got = (?$modifiers:a)
#     \$expected = (?$modifiers:b)
ERR
}


# false values that should not compare equal
{
    ok !is_deeply( 0, '', &quot;0 != ''&quot; );
    is( $out, &quot;not ok 30 - 0 != ''\n&quot; );
    ok !is_deeply( 0, undef, &quot;0 != undef&quot; );
    is( $out,    &quot;not ok 31 - 0 != undef\n&quot; );
    ok !is_deeply( '', undef, &quot;'' != undef&quot; );
    is( $out,     &quot;not ok 32 - '' != undef\n&quot; );

    ok !is_deeply( [0], [''], &quot;[0] != ['']&quot; );
    is( $out,     &quot;not ok 33 - [0] != ['']\n&quot; );
    ok !is_deeply( [0], [undef], &quot;[0] != [undef]&quot; );
    is( $out,        &quot;not ok 34 - [0] != [undef]\n&quot; );
    ok !is_deeply( [''], [undef], &quot;[''] != [undef]&quot; );
    is( $out,         &quot;not ok 35 - [''] != [undef]\n&quot; );

    ok !is_deeply( [0], [], &quot;[0] != []&quot; );
    is( $out,   &quot;not ok 36 - [0] != []\n&quot; );
    ok !is_deeply( [undef], [], &quot;[undef] != []&quot; );
    is( $out,       &quot;not ok 37 - [undef] != []\n&quot; );
    ok !is_deeply( [''], [], &quot;[''] != []&quot; );
    is( $out,    &quot;not ok 38 - [''] != []\n&quot; );

    ok !is_deeply( {x =&gt; 0}, {x =&gt; ''}, &quot;{x =&gt; 0} != {x =&gt; ''}&quot; );
    is( $out,               &quot;not ok 39 - {x =&gt; 0} != {x =&gt; ''}\n&quot; );
    ok !is_deeply( {x =&gt; 0}, {x =&gt; undef}, &quot;{x =&gt; 0} != {x =&gt; undef}&quot; );
    is( $out,                  &quot;not ok 40 - {x =&gt; 0} != {x =&gt; undef}\n&quot; );
    ok !is_deeply( {x =&gt; ''}, {x =&gt; undef}, &quot;{x =&gt; ''} != {x =&gt; undef}&quot; );
    is( $out,                   &quot;not ok 41 - {x =&gt; ''} != {x =&gt; undef}\n&quot; );
}</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/share/doc/perl-Test-Simple-0.98/t/is_deeply_fail.t'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Fshare%2Fdoc%2Fperl-Test-Simple-0.98%2Ft' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>