use warnings;
use strict;


use Test::More
    'no_plan'
    ;
use Test::NoWarnings;


VECTOR:
for my $ar_vector (
    #                           list of
    #     string         mask   extracted chars
    "normal cases",
    [     'ABCD',           0,              ],
    [     'ABCD',           1,  qw(      D) ],
    [     'ABCD',           2,  qw(    C  ) ],
    [     'ABCD',           3,  qw(    C D) ],
    [     'ABCD',           4,  qw(  B    ) ],
    [ 'WXYZABCD',           8,  qw(        A      ) ],
    [ 'WXYZABCD',           9,  qw(        A     D) ],
    [ 'WXYZABCD',          15,  qw(        A B C D) ],
    [ 'WXYZABCD',          16,  qw(      Z        ) ],
    [ 'WXYZABCD',          17,  qw(      Z       D) ],
    [ 'WXYZABCD',  0b00011111,  qw(      Z A B C D) ],
    [ 'WXYZABCD',  0b00100000,  qw(    Y          ) ],
    [ 'WXYZABCD',  0b00100001,  qw(    Y         D) ],
    [ 'WXYZABCD',         254,  qw(W X Y Z A B C  ) ],
    [ 'WXYZABCD',         255,  qw(W X Y Z A B C D) ],
    [ 'WXYZABCD',         256,  qw(               ) ],  # one beyond
    "limited numification of decimal strings works",
    [ 'WXYZABCD',         '0',                      ],
    [ 'WXYZABCD',       '255',  qw(W X Y Z A B C D) ],
    [ 'WXYZABCD',       '256',  qw(               ) ],  # one beyond
    "some degenerate cases",
    [         '',           0,  qw()  ],
    [         '',           1,  qw()  ],  # one beyond
    [         '',           2,  qw()  ],  # two beyond
    [        'A',           0,  qw( ) ],
    [        'A',           1,  qw(A) ],
    [        'A',           2,  qw( ) ],  # one beyond
    [        'A',           3,  qw(A) ],  # one beyond
    ) {

    if (ref $ar_vector ne 'ARRAY') {  # note/comment if not vector
        note $ar_vector;
        next VECTOR;
        }

    my ($string, $mask, @expected) = @$ar_vector;

    is_deeply [ extract($string, $mask) ], \@expected;

    # my @got = extract($string, $mask);
    # my $cmt =
    #   "'$string'  mask $mask  got(@got)  expect(@expected)";
    # is_deeply \@got, \@expected, $cmt;

    }


# subroutines ######################################################

sub extract {

    my ($string,  # string to extract chars from, given binary mask
        $mask,    # integer (0 .. 255) representing binary mask
        ) = @_;

    my @characters = split //, $string;
    $mask   = 0+$mask;           # numify mask (redundant?)
    my $bit = 1 << @characters;  # moving single-bit sub-mask

    return
        map  { $characters[$_]      }  # 3. return the char.
        grep { $mask & ($bit >>= 1) }  # 2. if its bit not 0...
        0 .. $#characters              # 1. each char in string...
        ;

    }
[download]