"Fossies" - the Fresh Open Source Software Archive

Member "RPerl-5.002000/t/10_precompiled_oo_inherit.t.DISABLED_EXPORTER" (30 Aug 2019, 41194 Bytes) of package /linux/misc/RPerl-5.002000.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Perl source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "10_precompiled_oo_inherit.t.DISABLED_EXPORTER": 4.001000_vs_4.002000.

    1 #!/usr/bin/env perl
    2 
    3 # NEED FIX: various bugs, including...
    4 # Subroutine RPerl::Algorithm::inherited_Algorithm redefined at /usr/lib/perl/5.18/DynaLoader.pm line 207.
    5 # Constant subroutine RPerl::Algorithm::TIME_BEST redefined at /usr/lib/x86_64-linux-gnu/perl/5.22/DynaLoader.pm line 210.
    6 
    7 # [[[ PRE-HEADER ]]]
    8 # suppress 'WEXRP00: Found multiple rperl executables' due to blib/ & pre-existing installation(s),
    9 # also 'WARNING WCOCODE00, COMPILER, FIND DEPENDENCIES: Failed to eval-use package' due to RPerl/Test/*/*Bad*.pm & RPerl/Test/*/*bad*.pl
   10 BEGIN { $ENV{RPERL_WARNINGS} = 0; }
   11 
   12 # [[[ HEADER ]]]
   13 use strict;
   14 use warnings;
   15 use RPerl::AfterSubclass;
   16 our $VERSION = 0.009_000;
   17 
   18 # [[[ CRITICS ]]]
   19 ## no critic qw(ProhibitUselessNoCritic ProhibitMagicNumbers RequireCheckedSyscalls)  # USER DEFAULT 1: allow numeric values & print operator
   20 ## no critic qw(RequireInterpolationOfMetachars)  # USER DEFAULT 2: allow single-quoted control characters & sigils
   21 ## no critic qw(RequireCheckingReturnValueOfEval)  ## SYSTEM DEFAULT 4: allow eval() test code blocks
   22 
   23 # [[[ INCLUDES ]]]
   24 use Test::More tests => 521;
   25 use Test::Exception;
   26 use RPerl::Test;
   27 use File::Copy;
   28 use Module::Refresh;
   29 use Sub::Delete;
   30 
   31 # [[[ OPERATIONS ]]]
   32 
   33 BEGIN {
   34     if ( $ENV{RPERL_VERBOSE} ) {
   35         Test::More::diag('[[[ Beginning Class Inheritance Pre-Test Loading, RPerl Object System ]]]');
   36     }
   37     lives_and( sub { use_ok('RPerl::AfterSubclass'); }, q{use_ok('RPerl::AfterSubclass') lives} );
   38     lives_and( sub { use_ok('RPerl::Compiler'); }, q{use_ok('RPerl::Compiler') lives} );
   39 
   40     # NEED ANSWER: why does all this code have to be inside a BEGIN block???
   41 
   42     # NEED FIX: duplicate code, is it redundant to do this here and also at the top of the main for() loop?
   43     my string $bubble_cpp_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.cpp' );
   44     my string $bubble_h_filename   = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.h' );
   45     my string $bubble_pmc_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.pmc' );
   46 
   47     my string $sort_cpp_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.cpp' );
   48     my string $sort_h_filename   = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.h' );
   49     my string $sort_pmc_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.pmc' );
   50 
   51     my string $inefficient_cpp_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.cpp' );
   52     my string $inefficient_h_filename   = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.h' );
   53     my string $inefficient_pmc_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.pmc' );
   54 
   55     my string $algorithm_cpp_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.cpp' );
   56     my string $algorithm_h_filename   = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.h' );
   57     my string $algorithm_pmc_filename = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.pmc' );
   58 
   59     #    RPerl::diag('in 10_precompiled_oo_inherit.t, have $bubble_pmc_filename = ' . $bubble_pmc_filename . "\n");
   60 
   61     # NEED FIX: triplicate code, is it redundant to do this here and also at the top of the main for() loop?
   62     # delete CPP, H, and PMC files if they exist;
   63     # for PERLOPS_PERLTYPES we need none of these files; for CPPOPS_xTYPES we need the proper manually-compiled files, not some other files
   64     foreach my string $filename (
   65         @{  [   $bubble_cpp_filename,      $bubble_h_filename,      $bubble_pmc_filename,      $sort_cpp_filename,
   66                 $sort_h_filename,          $sort_pmc_filename,      $inefficient_cpp_filename, $inefficient_h_filename,
   67                 $inefficient_pmc_filename, $algorithm_cpp_filename, $algorithm_h_filename,     $algorithm_pmc_filename
   68             ]
   69         }
   70         )
   71     {
   72         if ( -e $filename ) {
   73             my integer $unlink_success = unlink $filename;
   74             if ($unlink_success) {
   75                 ok( 1, 'Unlink (delete) existing file ' . $filename );
   76             }
   77             else {
   78                 ok( 0, 'Unlink (delete) existing file ' . $filename . q{ ... } . $OS_ERROR );
   79 
   80                 # skip all tests in this mode if we cannot remove the PMC file (and presumably the other 2 modes, as well)
   81                 next;
   82             }
   83         }
   84         else {
   85             ok( 1, 'No need to unlink (delete) existing file ' . $filename );
   86         }
   87     }
   88 
   89     # DEV NOTE, CORRELATION #rp015: suppress 'Too late to run INIT block' at run-time loading via require or eval
   90     lives_and( sub { require_ok('RPerl::Algorithm::Sort::Bubble'); }, q{require_ok('RPerl::Algorithm::Sort::Bubble') lives} );
   91     lives_and( sub { require_ok('RPerl::Algorithm::Inefficient'); },  q{require_ok('RPerl::Algorithm::Inefficient') lives} );
   92 }
   93 
   94 my string $bubble_pm_filename      = 'RPerl/Algorithm/Sort/Bubble.pm';
   95 my string $sort_pm_filename        = 'RPerl/Algorithm/Sort.pm';
   96 my string $inefficient_pm_filename = 'RPerl/Algorithm/Inefficient.pm';
   97 my string $algorithm_pm_filename   = 'RPerl/Algorithm.pm';
   98 my object $refresher               = Module::Refresh->new();
   99 
  100 # NEED FIX: duplicate code
  101 my string $bubble_cpp_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.cpp' );
  102 my string $bubble_cpp_filename_manual = $bubble_cpp_filename . '.CPPOPS_DUALTYPES';
  103 #my string $bubble_cpp_filename_manual = $bubble_cpp_filename . '.CPPOPS_CPPTYPES';
  104 my string $bubble_h_filename          = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.h' );
  105 my string $bubble_h_filename_manual   = $bubble_h_filename . '.CPPOPS_DUALTYPES';
  106 #my string $bubble_h_filename_manual   = $bubble_h_filename . '.CPPOPS_CPPTYPES';
  107 my string $bubble_pmc_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort/Bubble.pmc' );
  108 my string $bubble_pmc_filename_manual = $bubble_pmc_filename . '.CPPOPS_DUALTYPES';
  109 
  110 my string $sort_cpp_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.cpp' );
  111 my string $sort_cpp_filename_manual = $sort_cpp_filename . '.CPPOPS_DUALTYPES';
  112 #my string $sort_cpp_filename_manual = $sort_cpp_filename . '.CPPOPS_CPPTYPES';
  113 my string $sort_h_filename          = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.h' );
  114 my string $sort_h_filename_manual   = $sort_h_filename . '.CPPOPS_DUALTYPES';
  115 #my string $sort_h_filename_manual   = $sort_h_filename . '.CPPOPS_CPPTYPES';
  116 my string $sort_pmc_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Sort.pmc' );
  117 my string $sort_pmc_filename_manual = $sort_pmc_filename . '.CPPOPS_DUALTYPES';
  118 
  119 my string $inefficient_cpp_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.cpp' );
  120 my string $inefficient_cpp_filename_manual = $inefficient_cpp_filename . '.CPPOPS_DUALTYPES';
  121 #my string $inefficient_cpp_filename_manual = $inefficient_cpp_filename . '.CPPOPS_CPPTYPES';
  122 my string $inefficient_h_filename          = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.h' );
  123 my string $inefficient_h_filename_manual   = $inefficient_h_filename . '.CPPOPS_DUALTYPES';
  124 #my string $inefficient_h_filename_manual   = $inefficient_h_filename . '.CPPOPS_CPPTYPES';
  125 my string $inefficient_pmc_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm/Inefficient.pmc' );
  126 my string $inefficient_pmc_filename_manual = $inefficient_pmc_filename . '.CPPOPS_DUALTYPES';
  127 
  128 my string $algorithm_cpp_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.cpp' );
  129 my string $algorithm_cpp_filename_manual = $algorithm_cpp_filename . '.CPPOPS_DUALTYPES';
  130 #my string $algorithm_cpp_filename_manual = $algorithm_cpp_filename . '.CPPOPS_CPPTYPES';
  131 my string $algorithm_h_filename          = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.h' );
  132 my string $algorithm_h_filename_manual   = $algorithm_h_filename . '.CPPOPS_DUALTYPES';
  133 #my string $algorithm_h_filename_manual   = $algorithm_h_filename . '.CPPOPS_CPPTYPES';
  134 my string $algorithm_pmc_filename        = RPerl::Compiler::post_processor__absolute_path_delete( $RPerl::INCLUDE_PATH . '/RPerl/Algorithm.pmc' );
  135 my string $algorithm_pmc_filename_manual = $algorithm_pmc_filename . '.CPPOPS_DUALTYPES';
  136 
  137 #RPerl::diag('in 10_precompiled_oo_inherit.t, have $bubble_pmc_filename = ' . $bubble_pmc_filename . "\n");
  138 #RPerl::diag('in 10_precompiled_oo_inherit.t, have $bubble_pmc_filename_manual = ' . $bubble_pmc_filename_manual . "\n");
  139 
  140 # [[[ PRIMARY RUNLOOP ]]]
  141 # [[[ PRIMARY RUNLOOP ]]]
  142 # [[[ PRIMARY RUNLOOP ]]]
  143 
  144 # loop 3 times, once for each mode: PERLOPS_PERLTYPES, PERLOPS_CPPTYPES, CPPOPS_CPPTYPES
  145 foreach my integer $mode_id ( sort keys %{$RPerl::MODES} ) {
  146 #for my integer $mode_id ( 0, 1, 2 ) {    # TEMPORARY DEBUGGING xOPS_xTYPES ONLY
  147 
  148     # [[[ MODE SETUP ]]]
  149     #    RPerl::diag("in 10_precompiled_oo_inherit.t, top of for() loop, have \$mode_id = $mode_id\n");
  150     my scalartype_hashref $mode = $RPerl::MODES->{$mode_id};
  151     my $ops                     = $mode->{ops};
  152     my $types                   = $mode->{types};
  153     my string $mode_tagline     = $ops . 'OPS_' . $types . 'TYPES';
  154     if ( $ENV{RPERL_VERBOSE} ) {
  155         Test::More::diag( '[[[ Beginning Class Inheritance Tests, RPerl Object System, ' . $ops . ' Operations & ' . $types . ' Data Types' . ' ]]]' );
  156     }
  157 
  158     lives_ok( sub { rperltypes::types_enable($types) }, q{Mode '} . $ops . ' Operations & ' . $types . ' Data Types' . q{' enabled in CPP header file(s)} );
  159 
  160     # NEED FIX: triplicate code
  161     # delete CPP, H, and PMC files if they exist;
  162     # for PERLOPS_PERLTYPES we need none of these files; for CPPOPS_xTYPES we need the proper manually-compiled files, not some other files
  163     foreach my string $filename (
  164         @{  [   $bubble_cpp_filename,      $bubble_h_filename,      $bubble_pmc_filename,      $sort_cpp_filename,
  165                 $sort_h_filename,          $sort_pmc_filename,      $inefficient_cpp_filename, $inefficient_h_filename,
  166                 $inefficient_pmc_filename, $algorithm_cpp_filename, $algorithm_h_filename,     $algorithm_pmc_filename
  167             ]
  168         }
  169         )
  170     {
  171         if ( -e $filename ) {
  172             my integer $unlink_success = unlink $filename;
  173             if ($unlink_success) {
  174                 ok( 1, 'Unlink (delete) existing file ' . $filename );
  175             }
  176             else {
  177                 ok( 0, 'Unlink (delete) existing file ' . $filename . q{ ... } . $OS_ERROR );
  178 
  179                 # skip all tests in this mode if we cannot remove the PMC file (and presumably the other 2 modes, as well)
  180                 next;
  181             }
  182         }
  183         else {
  184             ok( 1, 'No need to unlink (delete) existing file ' . $filename );
  185         }
  186     }
  187 
  188     if ( $ops eq 'PERL' ) {
  189 
  190 #        RPerl::diag('in 10_precompiled_oo_inherit.t, have Bubble symtab entries:' . "\n" . RPerl::analyze_class_symtab_entries('RPerl::Algorithm::Sort::Bubble') . "\n\n");
  191     }
  192     else {    # $ops eq 'CPP'
  193         foreach my string_arrayref $filenames (
  194             @{  [   [ $bubble_cpp_filename, $bubble_cpp_filename_manual ],
  195 
  196                     [ $bubble_h_filename,   $bubble_h_filename_manual ],
  197                     [ $bubble_pmc_filename, $bubble_pmc_filename_manual ],
  198                     [ $sort_cpp_filename,   $sort_cpp_filename_manual ],
  199                     [ $sort_h_filename,     $sort_h_filename_manual ],
  200                     [ $sort_pmc_filename,   $sort_pmc_filename_manual ],
  201 
  202                     [ $inefficient_cpp_filename, $inefficient_cpp_filename_manual ],
  203                     [ $inefficient_h_filename,   $inefficient_h_filename_manual ],
  204                     [ $inefficient_pmc_filename, $inefficient_pmc_filename_manual ],
  205 
  206                     [ $algorithm_cpp_filename, $algorithm_cpp_filename_manual ],
  207                     [ $algorithm_h_filename,   $algorithm_h_filename_manual ],
  208                     [ $algorithm_pmc_filename, $algorithm_pmc_filename_manual ]
  209                 ]
  210             }
  211             )
  212         {
  213             my string $filename              = $filenames->[0];
  214             my string $filename_manual       = $filenames->[1];
  215             my string $filename_short        = $filename;
  216             my string $filename_manual_short = $filename_manual;
  217             if ( ( length $filename_short ) > 55 )        { $filename_short        = '...' . substr $filename_short,        -55; }
  218             if ( ( length $filename_manual_short ) > 55 ) { $filename_manual_short = '...' . substr $filename_manual_short, -55; }
  219             if ( -e ($filename_manual) ) {
  220                 my integer $copy_success = copy( $filename_manual, $filename );
  221                 if ($copy_success) {
  222                     ok( 1, 'Copy manually-compiled file ' . $filename_manual_short . ' to ' . $filename_short );
  223                 }
  224                 else {
  225                     ok( 0, 'Copy manually-compiled file ' . $filename_manual_short . ' to ' . $filename_short . q{ ... } . $OS_ERROR );
  226                 }
  227             }
  228             else {
  229                 ok( 0, 'Copy manually-compiled file ' . $filename_manual_short . ' to ' . $filename_short . q{ ... } . 'File does not exist' );
  230             }
  231         }
  232 
  233         # C++ use, load, link
  234         # ALL 4 MODULES
  235         lives_ok( sub { $refresher->refresh_module($bubble_pm_filename) },      'Refresh previously-loaded module: ' . $bubble_pm_filename );
  236         lives_ok( sub { $refresher->refresh_module($sort_pm_filename) },        'Refresh previously-loaded module: ' . $sort_pm_filename );
  237         lives_ok( sub { $refresher->refresh_module($inefficient_pm_filename) }, 'Refresh previously-loaded module: ' . $inefficient_pm_filename );
  238         lives_ok( sub { $refresher->refresh_module($algorithm_pm_filename) },   'Refresh previously-loaded module: ' . $algorithm_pm_filename );
  239 
  240         # DEV NOTE, CORRELATION #rp015: suppress 'Too late to run INIT block' at run-time loading via require or eval
  241         # ONLY 2 MODULES
  242         lives_and( sub { require_ok('RPerl::Algorithm::Sort::Bubble'); }, q{require_ok('RPerl::Algorithm::Sort::Bubble') lives} );
  243         lives_and( sub { require_ok('RPerl::Algorithm::Inefficient'); },  q{require_ok('RPerl::Algorithm::Inefficient') lives} );
  244 
  245         # force reload
  246         # ONLY 2 MODULES
  247         delete $main::{'RPerl__Algorithm__Sort__Bubble__MODE_ID'};
  248         delete $main::{'RPerl__Algorithm__Inefficient__MODE_ID'};
  249 
  250         # DEV NOTE: must call long form of cpp_load() to bypass mysterious 'undefined subroutine' symtab weirdness
  251         # ONLY 2 MODULES
  252         #lives_ok( sub { RPerl::Algorithm::Sort::Bubble::cpp_load(); }, q{RPerl::Algorithm::Sort::Bubble::cpp_load() lives} );
  253         lives_ok( sub { &{ $RPerl::Algorithm::Sort::Bubble::{'cpp_load'} }(); }, q{RPerl::Algorithm::Sort::Bubble::cpp_load() lives} );    # long form
  254         lives_ok( sub { &{ $RPerl::Algorithm::Inefficient::{'cpp_load'} }(); },  q{RPerl::Algorithm::Inefficient::cpp_load() lives} );     # long form
  255 
  256 #RPerl::diag('in 10_precompiled_oo_inherit.t, have post-re-use, post-re-cpp_load Bubble symtab entries:' . "\n" . RPerl::analyze_class_symtab_entries('RPerl::Algorithm::Sort::Bubble') . "\n\n");
  257     }
  258 
  259     foreach my string $type (
  260         qw(DataType__Integer DataType__Number DataType__String DataStructure__Array DataStructure__Hash Algorithm Algorithm__Sort Algorithm__Inefficient Algorithm__Sort__Bubble)
  261         )
  262     {
  263         lives_and(
  264             sub {
  265                 is( $RPerl::MODES->{ main->can( 'RPerl__' . $type . '__MODE_ID' )->() }->{ops},
  266                     $ops, 'main::RPerl__' . $type . '__MODE_ID() ops returns ' . $ops );
  267             },
  268             'main::RPerl__' . $type . '__MODE_ID() lives'
  269         );
  270         lives_and(
  271             sub {
  272                 is( $RPerl::MODES->{ main->can( 'RPerl__' . $type . '__MODE_ID' )->() }->{types},
  273                     $types, 'main::RPerl__' . $type . '__MODE_ID() types returns ' . $types );
  274             },
  275             'main::RPerl__' . $type . '__MODE_ID() lives'
  276         );
  277     }
  278 
  279     # [[[ OO INHERITANCE TESTS ]]]
  280     # [[[ OO INHERITANCE TESTS ]]]
  281     # [[[ OO INHERITANCE TESTS ]]]
  282 
  283     # [ BUBBLE ]
  284 
  285     # TOOIN00
  286     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'new' );
  287     my $bubbler = new_ok('RPerl::Algorithm::Sort::Bubble');
  288 
  289     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Bubble' );
  290     lives_ok(    # TOOIN01
  291         sub { $bubbler->inherited_Bubble('Frozen') },
  292         q{TOOIN01 inherited_Bubble('Frozen') lives}
  293     );
  294 
  295     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Sort' );
  296     lives_ok(    # TOOIN02
  297         sub { $bubbler->inherited_Sort('Frozen') },
  298         q{TOOIN02 inherited_Sort('Frozen') lives}
  299     );
  300 
  301     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Algorithm' );
  302     lives_ok(    # TOOIN03
  303         sub { $bubbler->inherited_Algorithm('Frozen') },
  304         q{TOOIN03 inherited_Algorithm('Frozen') lives}
  305     );
  306 
  307     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited' );
  308     lives_ok(    # TOOIN04
  309         sub { $bubbler->inherited('Logan') },
  310         q{TOOIN04 inherited('Logan') lives}
  311     );
  312 
  313 
  314 
  315 
  316 #    $refresher->refresh_module($bubble_pm_filename);
  317 #    print '[[[ in t/10 before eval()... ]]]', "\n";
  318 #    print eval 'use RPerl::Algorithm::Sort::Bubble;';
  319 #    print eval 'require q{RPerl/Algorithm/Sort/Bubble.pmc};';
  320 #    if ($EVAL_ERROR) { die 'in t/10' . "\n" . $EVAL_ERROR . ', dying'; }
  321 #    print '[[[ in t/10 after eval()... ]]]', "\n";
  322 
  323 #undef &RPerl::Algorithm::Sort::Bubble::uninherited_Bubble;
  324 #delete_sub 'RPerl::Algorithm::Sort::Bubble::uninherited_Bubble';
  325 
  326 =DISABLED_NEED_DELETE
  327 
  328 #undef &RPerl::Algorithm::Sort::Bubble::integer_bubblesort;
  329 #*RPerl::Algorithm::Sort::Bubble::integer_bubblesort = sub { return main::RPerl__Algorithm__Sort__Bubble__integer_bubblesort(@ARG); };
  330 *RPerl::Algorithm::Sort::Bubble::integer_bubblesort = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::integer_bubblesort() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__integer_bubblesort(@ARG); };
  331 #undef &RPerl::Algorithm::Sort::Bubble::number_bubblesort;
  332 #*RPerl::Algorithm::Sort::Bubble::number_bubblesort = sub { return main::RPerl__Algorithm__Sort__Bubble__number_bubblesort(@ARG); };
  333 *RPerl::Algorithm::Sort::Bubble::number_bubblesort = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::number_bubblesort() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__number_bubblesort(@ARG); };
  334 #undef &RPerl::Algorithm::Sort::Bubble::uninherited_Bubble;
  335 #*RPerl::Algorithm::Sort::Bubble::uninherited_Bubble = sub { return main::RPerl__Algorithm__Sort__Bubble__uninherited_Bubble(@ARG); };
  336 *RPerl::Algorithm::Sort::Bubble::uninherited_Bubble = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::uninherited_Bubble() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__uninherited_Bubble(@ARG); };
  337 #undef &RPerl::Algorithm::Sort::Bubble::uninherited;
  338 #*RPerl::Algorithm::Sort::Bubble::uninherited = sub { return main::RPerl__Algorithm__Sort__Bubble__uninherited(@ARG); };
  339 *RPerl::Algorithm::Sort::Bubble::uninherited = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::uninherited() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__uninherited(@ARG); };
  340 #undef &RPerl::Algorithm::Sort::Bubble::integer_bubblesort_typetest0;
  341 #*RPerl::Algorithm::Sort::Bubble::integer_bubblesort_typetest0 = sub { return main::RPerl__Algorithm__Sort__Bubble__integer_bubblesort_typetest0(@ARG); };
  342 *RPerl::Algorithm::Sort::Bubble::integer_bubblesort_typetest0 = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::integer_bubblesort_typetest0() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__integer_bubblesort_typetest0(@ARG); };
  343 #undef &RPerl::Algorithm::Sort::Bubble::number_bubblesort_typetest0;
  344 #*RPerl::Algorithm::Sort::Bubble::number_bubblesort_typetest0 = sub { return main::RPerl__Algorithm__Sort__Bubble__number_bubblesort_typetest0(@ARG); };
  345 *RPerl::Algorithm::Sort::Bubble::number_bubblesort_typetest0 = sub { print '[[[ in t/10 SUBROUTINE SHIM RPerl::Algorithm::Sort::Bubble::number_bubblesort_typetest0() ]]]', "\n"; return main::RPerl__Algorithm__Sort__Bubble__number_bubblesort_typetest0(@ARG); };
  346 
  347 =cut
  348 
  349 
  350 
  351 
  352 
  353     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'uninherited_Bubble' );
  354 #    can_ok( 'RPerl::Algorithm::Sort::Bubble', 'uninherited_Bubbbbbbble' );
  355     lives_and(    # TOOIN05
  356         sub {
  357 
  358 # START HERE: why are all the uninherited_*() subs registering via can_ok() but the fail to be located when actually running in is() below via CPPOPS_*TYPES???
  359 # START HERE: why are all the uninherited_*() subs registering via can_ok() but the fail to be located when actually running in is() below via CPPOPS_*TYPES???
  360 # START HERE: why are all the uninherited_*() subs registering via can_ok() but the fail to be located when actually running in is() below via CPPOPS_*TYPES???
  361 
  362             is( RPerl::Algorithm::Sort::Bubble::uninherited_Bubble('Claws'),
  363 #            is( main::RPerl__Algorithm__Sort__Bubble__uninherited_Bubble('Claws'),
  364                 'Bubble::uninherited_Bubble() RULES! ' . $mode_tagline,
  365                 q{TOOIN05 uninherited_Bubble('Claws') returns correct value}
  366             );
  367         },
  368         q{TOOIN05 uninherited_Bubble('Claws') lives}
  369     );
  370 
  371 
  372 
  373 
  374 
  375 
  376     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'uninherited' );
  377     lives_and(    # TOOIN06
  378         sub {
  379             is( RPerl::Algorithm::Sort::Bubble::uninherited('Wolverine'),
  380                 'Bubble::uninherited() ROCKS! ' . $mode_tagline,
  381                 q{TOOIN06 uninherited('Wolverine') returns correct value}
  382             );
  383         },
  384         q{TOOIN06 uninherited('Wolverine') lives}
  385     );
  386 
  387     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'get_foo' );
  388     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'set_foo' );
  389     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Bubble_foo_get' );
  390     lives_and(    # TOOIN07 - TOOIN11
  391         sub {
  392             is( $bubbler->get_foo(),
  393                 '<<< DEFAULT, ALGORITHM >>>',
  394                 q{TOOIN07 get_foo() returns correct value}
  395             );
  396             is( $bubbler->inherited_Bubble_foo_get(),
  397                 '<<< DEFAULT, ALGORITHM >>>',
  398                 q{TOOIN08 inherited_Bubble_foo_get() returns correct value}
  399             );
  400             $bubbler->set_foo('Alpha Flight');
  401             is( $bubbler->get_foo(),
  402                 'Alpha Flight',
  403                 q{TOOIN09 set_foo('Alpha Flight') sets correct value}
  404             );
  405             is( $bubbler->inherited_Bubble_foo_get(),
  406                 'Alpha Flight',
  407                 q{TOOIN10 inherited_Bubble_foo_get() returns correct value}
  408             );
  409         },
  410         q{TOOIN11 set_foo('Alpha Flight') lives}
  411     );
  412 
  413     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Bubble_foo_set' );
  414     lives_and(    # TOOIN12 - TOOIN16
  415         sub {
  416             is( $bubbler->get_foo(),
  417                 'Alpha Flight',
  418                 q{TOOIN12 get_foo() returns correct value}
  419             );
  420             is( $bubbler->inherited_Bubble_foo_get(),
  421                 'Alpha Flight',
  422                 q{TOOIN13 inherited_Bubble_foo_get() returns correct value}
  423             );
  424             $bubbler->inherited_Bubble_foo_set('Avengers');
  425             is( $bubbler->get_foo(),
  426                 'Avengers',
  427                 q{TOOIN14 inherited_Bubble_foo_set('Avengers') sets correct value}
  428             );
  429             is( $bubbler->inherited_Bubble_foo_get(),
  430                 'Avengers',
  431                 q{TOOIN15 inherited_Bubble_foo_get() returns correct value}
  432             );
  433         },
  434         q{TOOIN16 inherited_Bubble_foo_set('Avengers') lives}
  435     );
  436 
  437     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Sort_foo_get' );
  438     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Sort_foo_set' );
  439     lives_and(    # TOOIN17 - TOOIN21
  440         sub {
  441             is( $bubbler->get_foo(),
  442                 'Avengers',
  443                 q{TOOIN17 get_foo() returns correct value}
  444             );
  445             is( $bubbler->inherited_Sort_foo_get(),
  446                 'Avengers',
  447                 q{TOOIN18 inherited_Sort_foo_get() returns correct value}
  448             );
  449             $bubbler->inherited_Sort_foo_set('X-Men');
  450             is( $bubbler->get_foo(),
  451                 'X-Men',
  452                 q{TOOIN19 inherited_Sort_foo_set('X-Men') sets correct value}
  453             );
  454             is( $bubbler->inherited_Sort_foo_get(),
  455                 'X-Men',
  456                 q{TOOIN20 inherited_Sort_foo_get() returns correct value}
  457             );
  458         },
  459         q{TOOIN21 inherited_Sort_foo_set('X-Men') lives}
  460     );
  461 
  462     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Algorithm_foo_get' );
  463     can_ok( 'RPerl::Algorithm::Sort::Bubble', 'inherited_Algorithm_foo_set' );
  464     lives_and(    # TOOIN22 - TOOIN
  465         sub {
  466             is( $bubbler->get_foo(),
  467                 'X-Men',
  468                 q{TOOIN22 get_foo() returns correct value}
  469             );
  470             is( $bubbler->inherited_Algorithm_foo_get(),
  471                 'X-Men',
  472                 q{TOOIN23 inherited_Algorithm_foo_get() returns correct value}
  473             );
  474             $bubbler->inherited_Algorithm_foo_set('Weapon X');
  475             is( $bubbler->get_foo(),
  476                 'Weapon X',
  477                 q{TOOIN24 inherited_Algorithm_foo_set('Weapon X') sets correct value}
  478             );
  479             is( $bubbler->inherited_Algorithm_foo_get(),
  480                 'Weapon X',
  481                 q{TOOIN25 inherited_Algorithm_foo_get() returns correct value}
  482             );
  483         },
  484         q{TOOIN26 inherited_Algorithm_foo_set('Weapon X') lives}
  485     );
  486 
  487 
  488     # [ SORT ]
  489 
  490     # TOOIN27
  491     can_ok( 'RPerl::Algorithm::Sort', 'new' );
  492     my $sorter = new_ok('RPerl::Algorithm::Sort');
  493 
  494     can_ok( 'RPerl::Algorithm::Sort', 'uninherited_Sort' );
  495     lives_and(    # TOOIN28
  496         sub {
  497             is( RPerl::Algorithm::Sort::uninherited_Sort('Claws'),
  498                 'Sort::uninherited_Sort() RULES! ' . $mode_tagline,
  499                 q{TOOIN28 uninherited_Sort('Claws') returns correct value}
  500             );
  501         },
  502         q{TOOIN28 uninherited_Sort('Claws') lives}
  503     );
  504 
  505     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Sort' );
  506     lives_ok(    # TOOIN29
  507         sub { $sorter->inherited_Sort('Frozen') },
  508         q{TOOIN29 inherited_Sort('Frozen') lives}
  509     );
  510 
  511     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Algorithm' );
  512     lives_ok(    # TOOIN30
  513         sub { $sorter->inherited_Algorithm('Frozen') },
  514         q{TOOIN30 inherited_Algorithm('Frozen') lives}
  515     );
  516 
  517     can_ok( 'RPerl::Algorithm::Sort', 'get_foo' );
  518     can_ok( 'RPerl::Algorithm::Sort', 'set_foo' );
  519     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Sort_foo_get' );
  520     lives_and(    # TOOIN31 - TOOIN35
  521         sub {
  522             is( $sorter->get_foo(),
  523                 '<<< DEFAULT, ALGORITHM >>>',
  524                 q{TOOIN31 get_foo() returns correct value}
  525             );
  526             is( $sorter->inherited_Sort_foo_get(),
  527                 '<<< DEFAULT, ALGORITHM >>>',
  528                 q{TOOIN32 inherited_Sort_foo_get() returns correct value}
  529             );
  530             $sorter->set_foo('Alpha Flight');
  531             is( $sorter->get_foo(),
  532                 'Alpha Flight',
  533                 q{TOOIN33 set_foo('Alpha Flight') sets correct value}
  534             );
  535             is( $sorter->inherited_Sort_foo_get(),
  536                 'Alpha Flight',
  537                 q{TOOIN34 inherited_Sort_foo_get() returns correct value}
  538             );
  539         },
  540         q{TOOIN35 set_foo('Alpha Flight') lives}
  541     );
  542 
  543     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Sort_foo_set' );
  544     lives_and(    # TOOIN36 - TOOIN40
  545         sub {
  546             is( $sorter->get_foo(),
  547                 'Alpha Flight',
  548                 q{TOOIN36 get_foo() returns correct value}
  549             );
  550             is( $sorter->inherited_Sort_foo_get(),
  551                 'Alpha Flight',
  552                 q{TOOIN37 inherited_Sort_foo_get() returns correct value}
  553             );
  554             $sorter->inherited_Sort_foo_set('Avengers');
  555             is( $sorter->get_foo(),
  556                 'Avengers',
  557                 q{TOOIN38 inherited_Sort_foo_set('Avengers') sets correct value}
  558             );
  559             is( $sorter->inherited_Sort_foo_get(),
  560                 'Avengers',
  561                 q{TOOIN39 inherited_Sort_foo_get() returns correct value}
  562             );
  563         },
  564         q{TOOIN40 inherited_Sort_foo_set('Avengers') lives}
  565     );
  566 
  567     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Algorithm_foo_get' );
  568     can_ok( 'RPerl::Algorithm::Sort', 'inherited_Algorithm_foo_set' );
  569     lives_and(    # TOOIN41 - TOOIN45
  570         sub {
  571             is( $sorter->get_foo(),
  572                 'Avengers',
  573                 q{TOOIN41 get_foo() returns correct value}
  574             );
  575             is( $sorter->inherited_Algorithm_foo_get(),
  576                 'Avengers',
  577                 q{TOOIN42 inherited_Algorithm_foo_get() returns correct value}
  578             );
  579             $sorter->inherited_Algorithm_foo_set('X-Men');
  580             is( $sorter->get_foo(),
  581                 'X-Men',
  582                 q{TOOIN43 inherited_Algorithm_foo_set('X-Men') sets correct value}
  583             );
  584             is( $sorter->inherited_Algorithm_foo_get(),
  585                 'X-Men',
  586                 q{TOOIN44 inherited_Algorithm_foo_get() returns correct value}
  587             );
  588         },
  589         q{TOOIN45 inherited_Algorithm_foo_set('X-Men') lives}
  590     );
  591 
  592 
  593     # [ INEFFICIENT ]
  594 
  595     # TOOIN46
  596     can_ok( 'RPerl::Algorithm::Inefficient', 'new' );
  597     my $inefficient = new_ok('RPerl::Algorithm::Inefficient');
  598 
  599     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Inefficient' );
  600     lives_ok(    # TOOIN47
  601         sub { $inefficient->inherited_Inefficient('Frozen') },
  602         q{TOOIN47 inherited_Inefficient('Frozen') lives}
  603     );
  604 
  605     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Algorithm' );
  606     lives_ok(    # TOOIN48
  607         sub { $inefficient->inherited_Algorithm('Frozen') },
  608         q{TOOIN48 inherited_Algorithm('Frozen') lives}
  609     );
  610 
  611     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited' );
  612     lives_ok(    # TOOIN49
  613         sub { $inefficient->inherited('Logan') },
  614         q{TOOIN49 inherited('Logan') lives}
  615     );
  616 
  617     can_ok( 'RPerl::Algorithm::Inefficient', 'uninherited_Inefficient' );
  618     lives_and(    # TOOIN50
  619         sub {
  620             is( RPerl::Algorithm::Inefficient::uninherited_Inefficient('Claws'),
  621                 'Inefficient::uninherited_Inefficient() RULES! ' . $mode_tagline,
  622                 q{TOOIN50 uninherited_Inefficient('Claws') returns correct value}
  623             );
  624         },
  625         q{TOOIN50 uninherited_Inefficient('Claws') lives}
  626     );
  627 
  628     can_ok( 'RPerl::Algorithm::Inefficient', 'get_foo' );
  629     can_ok( 'RPerl::Algorithm::Inefficient', 'set_foo' );
  630     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Inefficient_foo_get' );
  631     lives_and(    # TOOIN51 - TOOIN55
  632         sub {
  633             is( $inefficient->get_foo(),
  634                 '<<< DEFAULT, ALGORITHM >>>',
  635                 q{TOOIN51 get_foo() returns correct value}
  636             );
  637             is( $inefficient->inherited_Inefficient_foo_get(),
  638                 '<<< DEFAULT, ALGORITHM >>>',
  639                 q{TOOIN52 inherited_Inefficient_foo_get() returns correct value}
  640             );
  641             $inefficient->set_foo('Alpha Flight');
  642             is( $inefficient->get_foo(),
  643                 'Alpha Flight',
  644                 q{TOOIN53 set_foo('Alpha Flight') sets correct value}
  645             );
  646             is( $inefficient->inherited_Inefficient_foo_get(),
  647                 'Alpha Flight',
  648                 q{TOOIN54 inherited_Inefficient_foo_get() returns correct value}
  649             );
  650         },
  651         q{TOOIN55 set_foo('Alpha Flight') lives}
  652     );
  653 
  654     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Inefficient_foo_set' );
  655     lives_and(    # TOOIN56 - TOOIN60
  656         sub {
  657             is( $inefficient->get_foo(),
  658                 'Alpha Flight',
  659                 q{TOOIN56 get_foo() returns correct value}
  660             );
  661             is( $inefficient->inherited_Inefficient_foo_get(),
  662                 'Alpha Flight',
  663                 q{TOOIN57 inherited_Inefficient_foo_get() returns correct value}
  664             );
  665             $inefficient->inherited_Inefficient_foo_set('Avengers');
  666             is( $inefficient->get_foo(),
  667                 'Avengers',
  668                 q{TOOIN58 inherited_Inefficient_foo_set('Avengers') sets correct value}
  669             );
  670             is( $inefficient->inherited_Inefficient_foo_get(),
  671                 'Avengers',
  672                 q{TOOIN59 inherited_Inefficient_foo_get() returns correct value}
  673             );
  674         },
  675         q{TOOIN60 inherited_Inefficient_foo_set('Avengers') lives}
  676     );
  677 
  678     can_ok( 'RPerl::Algorithm::Inefficient', 'get_bar' );
  679     can_ok( 'RPerl::Algorithm::Inefficient', 'set_bar' );
  680     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Inefficient_bar_get' );
  681     lives_and(    # TOOIN61 - TOOIN65
  682         sub {
  683             is( $inefficient->get_bar(),
  684                 '<<< DEFAULT, INEFFICIENT >>>',
  685                 q{TOOIN61 get_bar() returns correct value}
  686             );
  687             is( $inefficient->inherited_Inefficient_bar_get(),
  688                 '<<< DEFAULT, INEFFICIENT >>>',
  689                 q{TOOIN62 inherited_Inefficient_bar_get() returns correct value}
  690             );
  691             $inefficient->set_bar('Alpha Flight');
  692             is( $inefficient->get_bar(),
  693                 'Alpha Flight',
  694                 q{TOOIN63 set_bar('Alpha Flight') sets correct value}
  695             );
  696             is( $inefficient->inherited_Inefficient_bar_get(),
  697                 'Alpha Flight',
  698                 q{TOOIN64 inherited_Inefficient_bar_get() returns correct value}
  699             );
  700         },
  701         q{TOOIN65 inherited_Inefficient_bar_set('Alpha Flight') lives}
  702     );
  703 
  704     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Inefficient_bar_set' );
  705     lives_and(    # TOOIN66 - TOOIN70
  706         sub {
  707             is( $inefficient->get_bar(),
  708                 'Alpha Flight',
  709                 q{TOOIN66 get_bar() returns correct value}
  710             );
  711             is( $inefficient->inherited_Inefficient_bar_get(),
  712                 'Alpha Flight',
  713                 q{TOOIN67 inherited_Inefficient_bar_get() returns correct value}
  714             );
  715             $inefficient->inherited_Inefficient_bar_set('Avengers');
  716             is( $inefficient->get_bar(),
  717                 'Avengers',
  718                 q{TOOIN68 inherited_Inefficient_bar_set('Avengers') sets correct value}
  719             );
  720             is( $inefficient->inherited_Inefficient_bar_get(),
  721                 'Avengers',
  722                 q{TOOIN69 inherited_Inefficient_bar_get() returns correct value}
  723             );
  724         },
  725         q{TOOIN70 inherited_Inefficient_bar_set('Avengers') lives}
  726     );
  727 
  728     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Algorithm_foo_get' );
  729     can_ok( 'RPerl::Algorithm::Inefficient', 'inherited_Algorithm_foo_set' );
  730     lives_and(    # TOOIN71 - TOOIN75
  731         sub {
  732             is( $inefficient->get_foo(),
  733                 'Avengers',
  734                 q{TOOIN71 get_foo() returns correct value}
  735             );
  736             is( $inefficient->inherited_Algorithm_foo_get(),
  737                 'Avengers',
  738                 q{TOOIN72 inherited_Algorithm_foo_get() returns correct value}
  739             );
  740             $inefficient->inherited_Algorithm_foo_set('X-Men');
  741             is( $inefficient->get_foo(),
  742                 'X-Men',
  743                 q{TOOIN73 inherited_Algorithm_foo_set('X-Men') sets correct value}
  744             );
  745             is( $inefficient->inherited_Algorithm_foo_get(),
  746                 'X-Men',
  747                 q{TOOIN74 inherited_Algorithm_foo_get() returns correct value}
  748             );
  749         },
  750         q{TOOIN75 inherited_Algorithm_foo_set('X-Men') lives}
  751     );
  752 
  753 
  754     # [ ALGORITHM ]
  755 
  756     # TOOIN76
  757     can_ok( 'RPerl::Algorithm', 'new' );
  758     my $algorithm = new_ok('RPerl::Algorithm');
  759 
  760     can_ok( 'RPerl::Algorithm', 'uninherited_Algorithm' );
  761     lives_and(    # TOOIN77
  762         sub {
  763             is( RPerl::Algorithm::uninherited_Algorithm('Claws'),
  764                 'Algorithm::uninherited_Algorithm() RULES! ' . $mode_tagline,
  765                 q{TOOIN77 uninherited_Algorithm('Claws') returns correct value}
  766             );
  767         },
  768         q{TOOIN77 uninherited_Algorithm('Claws') lives}
  769     );
  770 
  771     can_ok( 'RPerl::Algorithm', 'get_foo' );
  772     can_ok( 'RPerl::Algorithm', 'set_foo' );
  773     can_ok( 'RPerl::Algorithm', 'inherited_Algorithm_foo_get' );
  774     lives_and(    # TOOIN78 - TOOIN82
  775         sub {
  776             is( $algorithm->get_foo(),
  777                 '<<< DEFAULT, ALGORITHM >>>',
  778                 q{TOOIN78 get_foo() returns correct value}
  779             );
  780             is( $algorithm->inherited_Algorithm_foo_get(),
  781                 '<<< DEFAULT, ALGORITHM >>>',
  782                 q{TOOIN79 inherited_Algorithm_foo_get() returns correct value}
  783             );
  784             $algorithm->set_foo('Alpha Flight');
  785             is( $algorithm->get_foo(),
  786                 'Alpha Flight',
  787                 q{TOOIN80 set_foo('Alpha Flight') sets correct value}
  788             );
  789             is( $algorithm->inherited_Algorithm_foo_get(),
  790                 'Alpha Flight',
  791                 q{TOOIN81 inherited_Algorithm_foo_get() returns correct value}
  792             );
  793         },
  794         q{TOOIN82 set_foo('Alpha Flight') lives}
  795     );
  796 
  797     can_ok( 'RPerl::Algorithm', 'inherited_Algorithm_foo_set' );
  798     lives_and(    # TOOIN83 - TOOIN87
  799         sub {
  800             is( $algorithm->get_foo(),
  801                 'Alpha Flight',
  802                 q{TOOIN83 get_foo() returns correct value}
  803             );
  804             is( $algorithm->inherited_Algorithm_foo_get(),
  805                 'Alpha Flight',
  806                 q{TOOIN84 inherited_Algorithm_foo_get() returns correct value}
  807             );
  808             $algorithm->inherited_Algorithm_foo_set('Avengers');
  809             is( $algorithm->get_foo(),
  810                 'Avengers',
  811                 q{TOOIN85 inherited_Algorithm_foo_set('Avengers') sets correct value}
  812             );
  813             is( $algorithm->inherited_Algorithm_foo_get(),
  814                 'Avengers',
  815                 q{TOOIN86 inherited_Algorithm_foo_get() returns correct value}
  816             );
  817         },
  818         q{TOOIN87 inherited_Algorithm_foo_set('Avengers') lives}
  819     );
  820 
  821    # DEV NOTE, CORRELATION #rp004: inheritance testing, manually enable uninherited() in exactly one of Algorithm.*, Inefficient.*, Sort.*, or Bubble.*
  822    #    can_ok( 'RPerl::Algorithm::Inefficient', 'uninherited' );
  823    #    lives_and(    # TOOINxx
  824    #        sub {
  825    #            is( uninherited('Wolverine'), 'Inefficient::uninherited() ROCKS! ' . $mode_tagline, q{TOOINxx uninherited('Wolverine') returns correct value} );
  826    #        },
  827    #        q{TOOINxx uninherited('Wolverine') lives}
  828    #    );
  829 
  830 }
  831 
  832 # NEED FIX: triplicate code
  833 # delete CPP, H, and PMC files if they exist;
  834 # for PERLOPS_PERLTYPES we need none of these files; for CPPOPS_xTYPES we need the proper manually-compiled files, not some other files
  835 foreach my string $filename (
  836     @{  [   $bubble_cpp_filename,      $bubble_h_filename,      $bubble_pmc_filename,      $sort_cpp_filename,
  837             $sort_h_filename,          $sort_pmc_filename,      $inefficient_cpp_filename, $inefficient_h_filename,
  838             $inefficient_pmc_filename, $algorithm_cpp_filename, $algorithm_h_filename,     $algorithm_pmc_filename
  839         ]
  840     }
  841     )
  842 {
  843     {
  844         if ( -e $filename ) {
  845             my integer $unlink_success = unlink $filename;
  846             if ($unlink_success) {
  847                 ok( 1, 'Unlink (delete) existing file ' . $filename );
  848             }
  849             else {
  850                 ok( 0, 'Unlink (delete) existing file ' . $filename . q{ ... } . $OS_ERROR );
  851 
  852                 # skip all tests in this mode if we cannot remove the PMC file (and presumably the other 2 modes, as well)
  853                 next;
  854             }
  855         }
  856         else {
  857             ok( 1, 'No need to unlink (delete) existing file ' . $filename );
  858         }
  859     }
  860 }
  861 
  862 done_testing();