test-fix

#!/usr/bin/env perl
use strict;
use warnings;
use 5.10.1;
use lib do {
    package Local;                             # make 'Cwd' local to scope
    use Cwd 'realpath';
    realpath(__FILE__) =~ m#^(.*)/#;           # script's real path
    "$1/lib/perl5/site_perl";
};


sub usage {
    return <<'END_USAGE';
Options available:
  cover    run test with code coverage (needs all tests to pass)

END_USAGE
}

# Returns full path of the first command (of a list of commands) that can be
# found in path (similar to shell command 'which'). For commands which can be
# founds in several directories found in $PATH only the fist occurring path is
# reported. Returns empty list or undef if none of the commands could be found
# in path.
sub which {
    my (@cmd) = @_;
    my @path = split(":", $ENV{PATH});
    foreach my $cmd (@cmd) {
        foreach (@path) {
            my $full = "$_/$cmd";
            if (-f $full && -x _) { return $full }
        }
    }
    return ();
}

{
    my @cover_command;            # set below when using Devel::Cover
    BEGIN {
        if (@ARGV) {
            if ($ARGV[0] eq 'cover') {
                shift;
                require Devel::Cover;
                Devel::Cover->import(
                    qw/-coverage all -silent 1 +ignore/, qr{/Test/Most|test-fix}
                );
                my ($version)  = $^V =~ /^v(\d+\.\d+)/;
                @cover_command = which("cover", "cover-$version")
                    or die "$0: Cannot find command 'cover' or 'cover-$version'\n"
                        . "  (Are you sure Devel::Cover is installed?)\n"
                        . "  (MacPort: 'p5-devel-cover', apt-package: "
                        . "'libdevel-cover-perl')";
            } else {
                warn usage();
                # Block around exit is to hide it from 'exit' detector thingy.
                { exit 1 }
            }
        }
    }
    END { system @cover_command if @cover_command }
}

my $in_main = 1;
END {
    if ($? and $in_main) {
        warn
            "# #################################\n" .
            "# ##  THERE WERE FAILING TESTS!  ##\n" .
            "# #################################\n";
    }
}

# load Test::Most module
# (gracefully suggesting missing Debian package on failure)
BEGIN {
    my $in_main = undef;
    eval { require Test::Most }
        or die "Cannot load required perl module Test::Most\n",
            "Install module (on Debian/Ubuntu) with:\n\n",
            "    apt-get install libtest-most-perl\n\n";
    Test::Most->import();
}

use File::Path qw( mkpath rmtree );
use Carp 'confess';
$SIG{__DIE__} = \&Carp::confess;

our $Dir;
BEGIN {
    package Local;
    use Cwd qw/realpath/;
    ($Dir) = realpath(__FILE__) =~ m#^(.*)/#;
    require "$Dir/fix";                        # load 'fix' as a module
    Local::Modulino->import();
}

# Workarounds for 'Test::More::subtest()'
BEGIN {
    sub no_implicit_done_testing_in_subtest {  # return true if implicit
        open(my $o, ">&STDOUT");               #   'done_testing()' is
        open(my $e, ">&STDERR");               #   missing in 'subtest()'
        open(STDOUT, ">/dev/null");
        open(STDERR, ">/dev/null");
        my $ok = subtest(_ => sub { pass() });
        Test::More->builder->reset();
        open(STDOUT, ">&", $o);
        open(STDERR, ">&", $e);
        return !$ok;
    }
    if (not exists &subtest) {
        *subtest = sub {                       # subtest() missing in
            my ($name, $code) = @_;            #   Test::More
            $code->();
            note $name;
        };
    } elsif (no_implicit_done_testing_in_subtest()) {
        no warnings 'redefine';
        *subtest = sub($&) {                   # implicit done_testing()
            my ($name, $code) = @_;            #   missing in subtest()
            Test::More::subtest($name, sub {
                $code->();
                done_testing();
            });
        };
    }
}

our $name  = 'fix';
our $keep  = ".$name/keep";                     # keepstate directory
our $run   = ".$name/run";                      # runstate directory
our $stats = ".$name/stats";
our $fix   = "$Dir/fix";
our $testdir = make_tempdir($name);

###############################################################################
##                                                                           ##
##  Functions                                                                ##
##                                                                           ##
###############################################################################

# Delete file(s). Ignore errors if file is gone in the end.
sub delete_file {
    my (@file) = @_;
    foreach my $file (@file) {
        next unless -e $file;
        unlink($file) or die "Failed to delete file '$file': $!,";
    }
}

# Write to a temporary file, so that we know the inode number will change when
# a file is rewritten (which guarantees that a newly written file will have a
# different stat fingerprint, even if it have the same content). Thus we know
# don't have to use Time::HiRes to get sub-second resolution in the
# fingerprinting.
sub write_file {
    my %arg = @_;
    foreach my $file (keys %arg) {
        my $outfile = "$file--tmp";
        # create full path of file before writing file
        if (my ($dir) = $outfile =~ m#^(.*)/#) {
            die "Cannot create dir '$dir': File already exists\n"
                if -e $dir and not -d $dir;
            unless (-d $dir or mkpath($dir)) {
                warn "Cannot create dir '$dir'\n";
                return undef;
            }
        }
        open(my $out, '>', $outfile)
            or die "Cannot open file '$outfile' for writing: $!,";
        print $out $arg{$file};
        close($out)
            or die "Cannot close file '$outfile' after writing: $!,";
        rename($outfile, $file)
            or die "Cannot rename file '$outfile' -> '$file' after writing: $!,";
    }
}

# Write files, then make them executable.
sub write_exe_file {
    my %arg = @_;
    write_file(%arg);
    chmod(0755, $_) or die "Cannot chmod file '$_': $!\n" foreach keys %arg;
}

sub read_file {
    my ($file) = @_;
    open(my $in, '<', $file)
        or return undef;
    local $/ = undef;
    return <$in>;
}

# Return stat fingerprint (or empty string if file doesn't exist).
#
# Note: We can't use Time::HiRes here, since it only supports lstat() since
# February 2013. [https://rt.cpan.org/Public/Bug/Display.html?id=83356]
sub read_file_fingerprint {
    my ($file) = @_;
    my @stat = lstat($file);
    return join("-", @stat ? @stat[1, 2, 4, 5, 7, 9, 10] : ());
}

# Return hash of filenames (as keys) and stat fingerprints (as values).
sub fingerprints {
    my (@file) = @_;
    return map {
        $_ => read_file_fingerprint($_);
    } @file;
}

sub make_tempdir {
    my ($name) = @_;
    my $tempdir = `mktemp -td $name-XXXXXX`;
    chomp($tempdir);
    return $tempdir;
}

{
    my $count   = 1;
    my $current = '';
    sub enter_dir {
        my ($dir) = @_;
        $current = "$testdir/" . sprintf("%02d", $count++) . "-$dir";
        mkdir($current) or die "Cannot create '$current': $!,";
        chdir($current) or die "Cannot cd to '$current': $!,";
        $ENV{PWD} = $current;
        note "DIR: $ENV{PWD}";
    }
    sub get_dir { $current }
}

sub nl { join "", map "$_\n", @_ }

sub sha1 {
    my ($data) = @_;
    use Digest::SHA qw(sha1_base64);
    use Encode qw(encode_utf8);
    sha1_base64(encode_utf8($data));
}

# Return keys in hash, sorted by first by length, then alphabetically.
sub key(\%) {
    sort { length($a) <=> length($b) or $a cmp $b } keys %{ shift() };
}

sub serialize {
    my (%x) = @_;
    use Data::Dumper;
    local $Data::Dumper::Indent   = 1;
    local $Data::Dumper::Sortkeys = 1;
    local $Data::Dumper::Terse    = 1;
    return Dumper \%x;
}

# for use with keepstate()
sub SOURCE { 'source' }
sub TARGET { 'target' }
sub keepstate {
    my ($type, $content, $deps, $source, $result) = @_;
    # Add checksum from keepstate to each dependency.
    @$deps = map {
        [ map {
            my $checksum = sha1(
                exists $result->{$_}
                    ? $result->{$_}{cont}
                    : $source->{$_},
            );
            join(':', $_, $checksum);
        } @$_ ];
    } @{ $deps // [] };
    my %x;
    $x{type}     = $type;
    $x{deps}     = [ @$deps ] if @$deps;
    $x{checksum} = sha1($content) if defined $content;
    return serialize(%x);
}

# for use with run_fix_test() and runstate()
sub NO_RUNSTATE { 'aborted' }
sub UNCHANGED   { 'wont_rebuild' }
sub WONT_OVERWR { 'wont_overwrite' }
sub SHELL_FAIL  { 'shell_error' }
sub BUILD_FAIL  { 'buildscript_error' }
sub NOT_FOUND   { 'buildscript_not_found' }
sub KEPT_PREV   { 'rebuilt_but_kept_previous' }
sub REPL_ERASED { 'rebuilt_replaced_deleted' }
sub NEW_CONTENT { 'rebuilt_new_content' }
sub SRC_NOT_FOUND { 'source_dep_not_found' }
sub SRC_REGIST  { 'source_dep_registered' }
sub runstate {
    my ($build_status, $abort_status, $abort_target) = @_;
    my %x;
    $x{ABORT}        = $abort_target if defined($abort_status);
    $x{build_status} = $build_status if defined($build_status);
    return serialize(%x);
}

sub statsstate {
    my (@run_target) = @_;
    my %x;
    $x{run_count}   = scalar(@run_target) if @run_target;
    $x{run_targets} =       \@run_target  if @run_target;
    return serialize(%x);
}

sub catch {
    my ($code) = @_;
    my @result = eval {
        local $SIG{__DIE__} = undef;
        $code->();
    };
    return ($!, $@, @result);
}

sub shebang {
    my $path = which(shift);
    return "#!$path\n";
}

{
    sub TRUE  { 1 }
    sub FALSE { 0 }
    my %target_rewritten = (
        NO_RUNSTATE ,=> FALSE,      # unmodified targets, no runstate generated
        UNCHANGED   ,=> FALSE,
        WONT_OVERWR ,=> FALSE,
        SHELL_FAIL  ,=> FALSE,
        BUILD_FAIL  ,=> FALSE,
        KEPT_PREV   ,=> FALSE,
        SRC_REGIST  ,=> FALSE,
        REPL_ERASED ,=> TRUE,
        NEW_CONTENT ,=> TRUE,
    );
    my @args;
    END {
        if (@args) {
            note '-' x 60;
            note "FAILED";
            note "  Dir: $ENV{PWD}";
            note "  Cmd: fix @args";
            note '-' x 60;
        }
    }

    sub run_fix_test {
        my %arg = @_;
        $arg{before} //= sub {};
        $arg{after}  //= sub {};
        $arg{name}   //= 'NONE';
        die "run_fix_test() option 'name' must be string," if ref($arg{name});
        die "run_fix_test() option 'exit' must be integer,"
            if $arg{exit} !~ /^\d+$/;
        die "run_fix_test() option 'before' must be coderef,"
            if ref($arg{before}) ne 'CODE';
        die "run_fix_test() option 'after' must be coderef,"
            if ref($arg{after})  ne 'CODE';
        my %result = %{ $arg{result} // {} };
        my %source = %{ $arg{source} // {} };
        my @stats  = @{ $arg{stats}  // [] };
        @args      = @{ $arg{args}   // [] };

        # write source files
        foreach (key %source) {
            next unless defined $source{$_};
            my $is_buildscript = m#\.fix$#;
            $source{$_} = shebang('dash') . $source{$_} if $is_buildscript;
            write_exe_file($_ => $source{$_});
        }

        my @file = do {
            my @tempfile = map { "$_--fixing" } keys %result;
            delete_file @tempfile;
            (keys %source, @tempfile, keys %result);
        };

        my %pre  = fingerprints(@file);
        $arg{before}();                        # run 'before' hook
        unshift(@args, '--stats');             # insert '--stats' option
        unshift(@{ $stats[0] }, '--stats') if @stats;
        my $exit = system("$fix @args 2> stderr.txt");

        if (my $caught = $exit & 127) {        # exit on Ctrl-C
            my %signame;                       #   (or any other signal)
            use Config '%Config';
            @signame{ split ' ', $Config{sig_num} }
                = split ' ', $Config{sig_name};
            warn " *** Killed by SIG" . $signame{ $caught } . "\n";
            # Block around exit is to hide it from 'exit' detector thingy.
            { exit }
        }

        my $stderr = read_file('stderr.txt');  # check stderr output
        delete_file('stderr.txt');
        subtest $arg{name} => sub {

            unlike($stderr, qr/Use of uninitialized value/,
                "No Perl warning 'uninitialized value'");

            is($exit >> 8, $arg{exit},         # check exit status
                "Exit status");

            if (defined $arg{errmsg}) {        # check any error message
                my $info = nl("Try '$name --help' for more information.");
                is($stderr, $arg{errmsg} . $info, "Error message");
            }

            $arg{after}();                     # run 'after' hook
            my %post = fingerprints(@file);

            # check statsfile
            if (@stats == 0) {
                ok(!-e $stats, "Should not exist: $stats");
            } else {
                ok( -e $stats, "Should exist: $stats");
                my $gotten   = read_file($stats);
                my $expected = statsstate(@stats);
                is($gotten, $expected, "Content: $stats");
            }

            # check sourcefiles
            {
                foreach (key %source) {
                    ok(! -f $_, "Should not exist: $_")
                        if not defined $source{$_};
                }
                my @source = grep { defined $source{$_} } key(%source);
                ok(   -f $_,            "Should exist: $_" ) for @source;
                is($pre{$_}, $post{$_}, "Should be unchanged: $_") for @source;
            }

            # check tempfiles
            {
                my @tempfile = (
                    key(%source),
                    grep { not defined $result{$_}{temp} } key(%result),
                );
                foreach (@tempfile) {
                    my $file = "$_--fixing";
                    ok(! -f $file, "Should not exist: $file");
                }
                @tempfile = grep { defined $result{$_}{temp} } key(%result);
                foreach (@tempfile) {
                    my $file = "$_--fixing";
                    ok(  -f $file, "Should exist: $file");
                }
                foreach (@tempfile) {
                    my $file = "$_--fixing";
                    isnt($pre{$file}, $post{$file}, "Tempfile updated: $file");
                }
                foreach (@tempfile) {
                    my $file = "$_--fixing";
                    my $gotten   = read_file($file);
                    my $expected = $result{$_}{temp};
                    is($gotten, $expected, "Content: $file");
                }
            }

            # check targets
            {
                my @target;
                @target = grep { not defined $result{$_}{cont} } key(%result);
                ok(!-f $_, "Should not exist: $_") for @target;
                @target = grep {     defined $result{$_}{cont} } key(%result);
                ok( -f $_, "Should exist: $_"    ) for @target;
                foreach (@target) {            # rewritten targets
                    my $state = $result{$_}{state};
                    isnt($pre{$_}, $post{$_}, "Should be updated: $_")
                        if $target_rewritten{$state} == TRUE;
                }
                foreach (@target) {            # unmodified targets
                    my $state = $result{$_}{state};
                    is($pre{$_}, $post{$_}, "Should be unchanged: $_")
                        if $target_rewritten{$state} == FALSE;
                }
                foreach (@target) {            # if modified, check content
                    is(read_file($_), $result{$_}{cont}, "Content: $_")
                        if $pre{$_} ne $post{$_};
                }
            }

            # check runstate
            my @runstate = grep { $result{$_}{state} ne NO_RUNSTATE } key(%result);
            if (@runstate == 0) {              # no targets generated
                ok(!-e $run, "Should not exist: $run/");
            } else {                           # targets were generated
                ok( -e $run, "Should exist: $run/");
                foreach (key %result) {
                    ok(!-f "$run/$_", "Should not exist: $run/$_")
                        if $result{$_}{state} eq NO_RUNSTATE;
                }
                foreach (@runstate) {
                    ok( -f "$run/$_", "Should exist: $run/$_");
                }
                foreach (@runstate) {
                    my $gotten   = read_file("$run/$_");
                    my $expected = runstate(
                        $result{$_}{state},
                        ($result{$_}{abort} ? (ABORT => $result{$_}{abort}) : ()),
                    );
                    is($gotten, $expected, "Content: $run/$_");
                }
            }

            # check keepstate
            my @keepstate = grep { not exists $result{$_}{abort} } key(%result);
            if (@keepstate == 0) {
                # Source files with defined content which are in the worktree.
                my @source = grep {
                    defined($source{$_}) and not m#^\.\./#;
                } key %source;
                if (@source) {
                    ok( -e $keep, "Should exist: $keep/");
                } else {
                    ok(!-e $keep, "Should not exist: $keep/");
                }
            } else {
                ok( -e $keep, "Should exist: $keep/");
                foreach (key %source) {
                    my $gotten   = read_file("$keep/$_") // next;
                    my $expected = keepstate(SOURCE, $source{$_});
                    is($gotten, $expected, "Content: $keep/$_");
                }
                foreach (key %result) {
                    my $keepfile = "$keep/$_";
                    if (exists $result{$_}{abort}) {
                        is($pre{$_}, $post{$_}, "Should be unchanged: $_");
                    } else {
                        my $gotten   = read_file($keepfile);
                        my $type     = $result{$_}{type} // TARGET;
                        my $expected = keepstate($type,
                            $result{$_}{cont},
                            $result{$_}{deps},
                            \%source, \%result
                        );
                        is($gotten, $expected, "Content: $keepfile");
                    }
                }
            }
        } and @args = ();
    }
}

###############################################################################
##                                                                           ##
##  Initialization                                                           ##
##                                                                           ##
###############################################################################

sub help {
    $in_main = undef;
    print <<EOF;
Usage: test-fix [ --continue | --help ]
Run the fix test suite.

Options:
  -h, --help      display this help and exit
  -a, --all       run all tests (don't abort on first failure)

EOF
    { exit }
}

use Getopt::Long qw(:config posix_default gnu_compat no_ignore_case permute);
my $die_level = 'never';

my $die_on_fail = 1;
GetOptions(
    'all|a'    => sub { $die_on_fail = 0 },
    'help|h|?' => \&help,
);
die_on_fail if $die_on_fail;

# check if there is an 'exit' statement in this file
my $exit_statement_in_test_script = read_file(__FILE__) =~ /^\s*exit.*;/m;

###############################################################################
##                                                                           ##
##  White-Box Tests (Testing Functions in the Program)                       ##
##                                                                           ##
###############################################################################
note
    "======================================\n" .
    " White-Box Tests (Internal Functions)\n" .
    "======================================";

enter_dir("whitebox-tests");

subtest 'split_path()' => sub {
    # FIXME: What *should* split_path('.') return?
    my @test = (
        [ qw( a/b/c     a/b     c ) ],
        [ qw( a/b/c/    a/b     c ) ],
        [ qw( a/b/c///  a/b     c ) ],
        [ qw( a/b//c/   a/b     c ) ],
        [ qw( a//b/c    a//b    c ) ],
        [ qw( /a/b/c    /a/b    c ) ],
        [ qw( a         .       a ) ],
        [ qw( /a        /       a ) ],
    );
    # We run the function twice, because it looks prettier to report basenames and
    # dirnames separately in the output.
    foreach my $test (@test) {
        my ($path, $expect_dir, undef) = @$test;
        my ($dir_result, undef) = Local::Modulino::split_path($path);
        is ($dir_result, $expect_dir, "Dirname: $path");
    }
    foreach my $test (@test) {
        my ($path, undef, $expect_file) = @$test;
        my (undef, $file_result) = Local::Modulino::split_path($path);
        is ($file_result, $expect_file, "Basename: $path");
    }
};

subtest 'default_buildscripts()' => sub {
    my %tests = (
        'hej.a.b.c' => [
            'default.a.b.c.fix',
            'default.a.b.fix',
            'default.a.fix',
            'default.fix' ],
        'a' => [
            'default.fix' ],
    );
    for (key %tests) {
        my $expect = $tests{$_};
        is_deeply([ Local::Modulino::possible_buildscripts($_) ], $expect,
                  "Files: $_");
    }
};

subtest 'Local::Paths::relpath()' => sub {
    my @test = (
        [qw( /x/y/z.txt  /           x/y/z.txt )],
        [qw( /x/y/z.txt  /x            y/z.txt )],
        [qw( /x/y/z.txt  /x/y            z.txt )],
        [qw( /x/y/z.txt  /x/y/a       ../z.txt )],
        [qw( /x/y/z.txt  /x/y/a/b  ../../z.txt )],
        [qw( ../z.txt    .            ../z.txt )],
    );
    foreach (@test) {
        my ($file, $dir, $result) = @$_;
        my $got = Local::Paths::relpath($file, $dir);
        is($got, $result, "$result");
    }
};

subtest 'Local::Paths::clean()' => sub {
    my @test = (
        './a'        => 'a',
        '../a'       => '../a',
        '../../a'    => '../../a',
        '.'          => '.',
        './.'        => '.',
        './..'       => '..',
        './'         => '.',                   # odd corner case
        '/.'         => '/',                   # odd corner case
        '/'          => '/',
        '/a'         => '/a',
        '/a/..'      => '/',
        '/a/../..'   => '/',
        '/a/b/../..' => '/',
        'a'          => 'a',
        'a/'         => 'a',
        'a/../..'    => '..',
        'a/../../..' => '../..',
        'a/../b/c'   => 'b/c',
        'a/../../c'  => '../c',
        'a/./b'      => 'a/b',
        'a//b'       => 'a/b',
        'a/b'        => 'a/b',
        'a/b/../..'  => '.',
        'a/b/c/..'   => 'a/b',
    );
    while (@test) {
        my ($_, $expect) = splice(@test, 0, 2);
        is(Local::Paths::clean($_), $expect, "Path: $_");
    }
};

subtest "Local::Store, simple use" => sub {
    my $test = new Local::Store(dir => 'storage');
    my ($x, $y);

    $x = eval { $test->get('file'); 1 };
    is  ($x, undef, "get() without fields should die");
    like($@, qr/Missing arguments: No field names given/,
                    "get() without fields error message");

    $x = $test->get('file', 'foo');
    is  ($x, undef, "get() on non-existing field");
    $x = $test->set('file', foo => 'bar', apa => 'bepa');
    ok  ($x, "set() return status");
    for ('storage/file') {
        ok  ( -f $_, "set() file existence: $_");
        is  (read_file($_), serialize(foo => 'bar', apa => 'bepa'),
             "set() file content: $_");
    }

    ($x, $y) = $test->get('file', 'foo', 'apa');
    is  ($x, 'bar',  'get() with two existing fields, 1st field');
    is  ($y, 'bepa', 'get() with two existing fields, 2nd field');
    ($x, $y) = $test->get('file', 'apa', 'foo');
    is  ($x, 'bepa', 'get() with two existing fields in opposite order, 1st field');
    is  ($y, 'bar',  'get() with two existing fields in opposite order, 2nd field');

    my %expected = ( foo => 'bar', apa => 'bepa' );
    foreach (qw/foo apa/) {
        $x = $test->get('file', $_);
        is  ($x, $expected{$_}, "get() with one field in scalar context: $_");
    }
};

subtest "read_config()" => sub {
    my $file;
    my $next = sub { $file = sprintf('cfg%02d', state $i ++) };
    my $bad  = "Neither '[section]' nor 'variable = value'";
    my %config = (
        $next->() => {
            name   => 'Invalid line',
            cont   => nl('@ invalid line'),
            error  => nl("$bad in line 1"),
        },
        # comments
        $next->() => {
            name   => 'Two comment lines',
            cont   => nl('# hash comment', '; semicolor comment'),
            return => {},
        },
        $next->() => {
            name   => "Comment after '[section]'",
            cont   => nl('[section]# hash comment',
                         '[section]; semicolor comment'),
            return => {},
        },
        $next->() => {
            name   => "Valid section '[test]'",
            cont   => nl('[test]'),
            return => {},
        },
        $next->() => {
            name   => "Comment after 'variable = value'",
            cont   => nl('[section] # hash comment',
                         'variable = value;semicolon comment'),
            return => { section => { variable => 'value' }},
        },
        # section
        $next->() => {
            name   => 'Missing section name in line 1',
            cont   => nl('variable = value'),
            error  => nl("No '[section]' found in line 1")
        },
        $next->() => {
            name   => 'Missing section name in line 2',
            cont   => nl('', 'variable = value'),
            error  => nl("No '[section]' found in line 2")
        },
        $next->() => {
            name   => 'Invalid section name',
            cont   => nl('[invalid_section_only]'),
            error  => nl("$bad in line 1"),
        },
        $next->() => {
            name   => 'Invalid section name',
            cont   => nl('[valid-section-only]'),
            return => {},
        },
        $next->() => {
            name   => 'Invalid section with argument',
            cont   => nl('[section-with "value"]'),
            error  => nl("$bad in line 1"),
        },
        $next->() => {
            name   => 'Valid values in two sections',
            cont   => nl('[ section1 ]',
                     '    variable = value1',
                     '[ section2 ]',
                     '    variable = value2',
                     ''),
            return => { section1 => { variable => 'value1' },
                        section2 => { variable => 'value2' }},
        },
        # variable/value
        $next->() => {
            name   => 'Invalid single quoted variable',
            cont   => nl('[section]', "'variable' = value"),
            error  => nl("$bad in line 2"),
        },
        $next->() => {
            name   => 'Invalid double quoted variable',
            cont   => nl('[section]', '"variable" = value'),
            error  => nl("$bad in line 2"),
        },
        $next->() => {
            name   => 'Valid variable without value',
            cont   => nl('[section]', 'variable'),
            return => { section => { variable => '1' }},
        },
        $next->() => {
            name   => 'Valid unquoted value',
            cont   => nl('[section]', 'variable = value'),
            return => { section => { variable => 'value' }},
        },
        $next->() => {
            name   => 'Valid unquoted value on section line',
            cont   => nl('[section]variable = value'),
            return => { section => { variable => 'value' }},
        },
        $next->() => {
            name   => 'Ignored single quotes in value',
            cont   => nl('[section]',
                         "variable = 'value'"),
            return => { section =>{ variable => "'value'" }},
        },
        $next->() => {
            name   => 'Valid quoted value',
            cont   => nl('[section]',
                         'variable = ";-#-\\\\-\\"-\\n-\\t-\\b"'),
            return => { section =>{ variable => ";-#-\\-\"-\n-\t-\b" }},
        },
        $next->() => {
            name   => 'Valid mixed case variable name',
            cont   => nl('[section]',
                         'Variable =  "value"'),
            return => { section =>{ variable => "value" }},
        },
        $next->() => {
            name  => 'Valid unescaped multiple words in value',
            cont  => nl('[section]',
                        'variable = value value  '),
            return => { section =>{ variable => "value value" }},
        },
        $next->() => {
            name  => 'Valid unescaped multiple words with 2 spaces between',
            cont  => nl('[section]',
                        'variable = value  value  '),
            return => { section =>{ variable => "value  value" }},
        },
    );
    my ($err, $msg, %return) = catch sub {
        Local::Modulino::read_config('non-existing-file');
    };
    is($err, "No such file or directory", "Non-existing file: Exit status");
    is($msg, "Cannot open config file 'non-existing-file' for reading: " .
        "No such file or directory\n", "Non-existing file: Error message");
    foreach my $file (key %config) {
        my $name = $config{$file}{name};
        write_file($file, $config{$file}{cont});
        my ($err, $msg, %return) = catch sub {
            Local::Modulino::read_config($file);
        };
        if (exists $config{$file}{error}) {
            # Testing of $err in string context return wrong value on MacOS X.
            cmp_ok($err, '==', 254, "$file: $name: Exit status");
            is($msg, "Bad config '$file': $config{$file}{error}",
               "$file: $name: Error message");
        } else {
            is($err, '', "$file: $name: Exit status");
            is(Dumper(\%return), Dumper($config{$file}{return}),
               "$file: $name: Return value");
        }
    }
};

# Abort all tests unless 'fix' can be executed
# FIXME: hide standard output/error
my $exit = system $fix, '--version';
isnt($exit, -1, q|Must be able to execute 'fix' script|);
BAIL_OUT q|Cannot start greybox testing: 'fix' script isn't executable!|
    if $exit == -1;

###############################################################################
##                                                                           ##
##  Grey-Box Tests (Testing Build Results & State Storage Content)           ##
##                                                                           ##
###############################################################################
note
    "================================================\n" .
    " Grey-Box Tests (Build Results + State Storage)\n" .
    "================================================";

note '=== Passing Bad Args ===';
enter_dir("greybox-passing-bad-args");

run_fix_test(
    name   => "No '.fixrc'",
    exit   => 254,
    errmsg => nl("fix: Current dir not in a fix worktree",
                 "(Use 'touch .fixrc' where you want your worktree root.)"),
    args   => [qw( 1 )],
);

write_file('.fixrc' => '');

run_fix_test(
    name   => "Incorrect '.fix/store_version'",
    exit   => 254,
    errmsg => nl("fix: State storage on disk has old format, full rebuild needed",
                 "(Erase '.fix' directory in worktree root and run again.)"),
    args   => [qw( 1 )],
    before => sub {   mkdir(".$name"); write_file('.fix/store_version', '') },
    after  => sub {  rmtree(".$name") },
);

run_fix_test(
    name   => "No argument given",
    exit   => 254,
    errmsg => nl("fix: No target specified"),
    args   => [qw()],
);

run_fix_test(
    name   => "Bad command line option",
    exit   => 254,
    errmsg => nl("fix: Unknown option: '--BAD-OPTION'"),
    args   => [qw( --BAD-OPTION )],
);

run_fix_test(
    name   => "Two bad command line options",
    exit   => 254,
    errmsg => nl("fix: Unknown option: '--BAD-OPTION'",
                 "fix: Unknown option: '--BAD-OPTION-2'"),
    args   => [qw( --BAD-OPTION --BAD-OPTION-2 )],
);

run_fix_test(
    name   => "Option '--source' on command line",
    exit   => 254,
    errmsg => nl("fix: Option '--source' can only be used inside buildscript"),
    args   => [qw( --source NON-EXISTING-TARGET )],
);

# FIXME: Test output on standard error
run_fix_test(
    name   => "Non-existing buildscript",
    exit   => 254,
    args   =>  [qw( NON-EXISTING-TARGET )],
    stats  => [[qw( NON-EXISTING-TARGET )]],
    source => {
        'NON-EXISTING-TARGET.fix' => undef,
    },
    result => {
        'NON-EXISTING-TARGET' => {
            abort => 'NON-EXISTING-TARGET',
            state => NOT_FOUND,
        },
    },
);

# FIXME: Test output on standard error
run_fix_test(
    name   => "Buildscript outside worktree",
    exit   => 254,
    args   =>  [qw( ../outside )],
    stats  => [[qw( ../outside )]],
    source => {
        '../outside.fix' => '',
    },
    result => {
        '../outside' => {
            # No file given in 'abort', since '../outside.txt'
            # cannot be stored in keepstate.
            abort => '',
            state => NO_RUNSTATE,
        },
    },
);

# FIXME: Test output on standard error
run_fix_test(
    name   => "Buildscript with exit status = 1",
    exit   => 1,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo FIRST',
                      'exit 1',
                      'echo SECOND'),
    },
    result => {
        '1' => {
            state => BUILD_FAIL,
            deps  => [[ '1.fix' ]],
            temp  => nl('FIRST'),
        },
    },
);

# FIXME: Test output on standard error
run_fix_test(
    name   => "Buildscript with exit status = 2",
    exit   => 2,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo FIRST',
                      'exit 2',
                      'echo SECOND'),
    },
    result => {
        '1' => {
            state => BUILD_FAIL,
            deps  => [[ '1.fix' ]],
            temp  => nl('FIRST'),
        },
    },
);

# FIXME: Test output on standard error
run_fix_test(
    name   => "Buildscript with non-existing command",
    exit   => 127,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('NONEXISTING-SHELL-COMMAND'),
    },
    result => {
        '1' => {
            state => BUILD_FAIL,
            deps  => [[ '1.fix' ]],
            temp  => nl(),
        },
    },
);

###############################################################################

note '=== Config File ===';
enter_dir("greybox-config-file");
{
    my $dir = get_dir();

    write_file('.fixrc' => nl('[core]', '@'));
    run_fix_test(
        name   => "Invalid '.fixrc'",
        exit   => 254,
        errmsg => nl("fix: Bad config '.fixrc': Neither '[section]' nor " .
                         "'variable = value' in line 2"),
        args   =>  [qw( test.txt )],
    );

    write_file('.fixrc' => nl('[core]', 'execPath = wonkdir'));
    write_exe_file('wonkdir/wonky' => nl(shebang('sh'), 'echo wonkwonk1'));
    run_fix_test(
        name   => q|Run script in custom dir using 'execPath' | .
                  q|option in '.fixrc'|,
        exit   => 0,
        args   =>  [qw( test.txt )],
        stats  => [[qw( test.txt )]],
        source => {
            'test.txt.fix' => nl('wonky'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl('wonkwonk1'),
            },
        },
    );

    write_file('.fixrc' => '');
    rmtree([ ".$name", 'test.txt' ]);
    write_exe_file('wonkdir/wonky' => nl(shebang('sh'), 'echo wonkwonk2'));
    run_fix_test(
        name   => q|Run script in custom dir using '$FIX_EXEC_PATH' | .
                  q|in shell environment|,
        exit   => 0,
        args   =>  [qw( test.txt )],
        stats  => [[qw( test.txt )]],
        before => sub {        $ENV{FIX_EXEC_PATH} = 'wonkdir'  },
        after  => sub { delete $ENV{FIX_EXEC_PATH}        },
        source => {
            'test.txt.fix' => nl('wonky'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl('wonkwonk2'),
            },
        },
    );

    write_file('.fixrc' => '');
    rmtree([ ".$name", 'test.txt' ]);
    write_exe_file('wonkdir/wonky' => nl(shebang('sh'), 'echo wonkwonk3'));
    run_fix_test(
        name   => q|Run script in custom dir using '--exec-path' option |,
        exit   => 0,
        args   =>  [ qw( --exec-path=wonkdir test.txt )],
        stats  => [[ qw( --exec-path=wonkdir test.txt )]],
        source => {
            'test.txt.fix' => nl('wonky'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl('wonkwonk3'),
            },
        },
    );

    write_file('.fixrc' => nl('[core]', 'execPath = wonkdir-cfg'));
    rmtree([ ".$name", 'test.txt' ]);
    write_exe_file('wonkdir-env/wonky' => nl(shebang('sh'), 'echo wonkwonk-env'),
                   'wonkdir-cmd/wonky' => nl(shebang('sh'), 'echo wonkwonk-cmd'),
                   'wonkdir-cfg/wonky' => nl(shebang('sh'), 'echo wonkwonk-cfg'));
    run_fix_test(
        name   => q|Path specified with '--exec-path' should come | .
                  q|before paths specified on in config or environment|,
        exit   => 0,
        args   =>  [ qw( --exec-path=wonkdir-cmd test.txt )],
        stats  => [[ qw( --exec-path=wonkdir-cmd test.txt )]],
        before => sub {        $ENV{FIX_EXEC_PATH} = 'wonkdir-env' },
        after  => sub { delete $ENV{FIX_EXEC_PATH}          },
        source => {
            'test.txt.fix' => nl('wonky'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl("wonkwonk-cmd"),
            },
        },
    );

    write_file('.fixrc' => nl('[core]', 'execPath = wonkdir-cfg'));
    rmtree([ ".$name", 'test.txt' ]);
    write_exe_file('wonkdir-env/wonky' => nl(shebang('sh'), 'echo wonkwonk-env'),
                   'wonkdir-cmd/wonky' => nl(shebang('sh'), 'echo wonkwonk-cmd'),
                   'wonkdir-cfg/wonky' => nl(shebang('sh'), 'echo wonkwonk-cfg'));
    run_fix_test(
        name   => q|Path specified in config file should come before path | .
                  q|specified in environment|,
        exit   => 0,
        args   =>  [ qw( test.txt )],
        stats  => [[ qw( test.txt )]],
        before => sub {        $ENV{FIX_EXEC_PATH} = 'wonkdir-env' },
        after  => sub { delete $ENV{FIX_EXEC_PATH}          },
        source => {
            'test.txt.fix' => nl('wonky'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl("wonkwonk-env"),
            },
        },
    );

    write_file('.fixrc' => nl('[core]', 'execPath = wonkdir-cfg'));
    rmtree([ ".$name", 'test.txt' ]);
    write_exe_file('wonkdir-env/wonky1' => nl(shebang('sh'), 'echo wonkwonk2-env'),
                   'wonkdir-cmd/wonky2' => nl(shebang('sh'), 'echo wonkwonk2-cmd'),
                   'wonkdir-cfg/wonky3' => nl(shebang('sh'), 'echo wonkwonk2-cfg'));
    run_fix_test(
        name   => q|Path set with $FIX_EXEC_PATH, 'execPath' and | .
                  q|'--exec-path' should all work at the same time|,
        exit   => 0,
        args   =>  [ qw( --exec-path=wonkdir-cmd test.txt )],
        stats  => [[ qw( --exec-path=wonkdir-cmd test.txt )]],
        before => sub {        $ENV{FIX_EXEC_PATH} = 'wonkdir-env' },
        after  => sub { delete $ENV{FIX_EXEC_PATH}          },
        source => {
            'test.txt.fix' => nl('wonky1', 'wonky2', 'wonky3'),
        },
        result => {
            'test.txt' => {
                state => NEW_CONTENT,
                deps  => [[ 'test.txt.fix' ]],
                cont  => nl('wonkwonk2-env', 'wonkwonk2-cmd', 'wonkwonk2-cfg'),
            },
        },
    );
}

###############################################################################

note '=== Building with Default Buildscripts ===';
enter_dir("greybox-default-buildscripts");
write_file('.fixrc' => '');

run_fix_test(
    name   => "Build using '1.txt.fix' rule",
    exit   => 0,
    args   =>  [qw( 1.txt )],
    stats  => [[qw( 1.txt )]],
    source => {
        '1.txt.fix' => nl('echo $1',
                          'echo $2'),
    },
    result => {
        '1.txt' => {
            state => NEW_CONTENT,
            deps  => [[ '1.txt.fix' ]],
            cont  => nl("$ENV{PWD}/1.txt--fixing",
                        "$ENV{PWD}/1.txt"),
        },
    },
);
rmtree([ ".$name", '1.txt', '1.txt.fix' ]);    # erase generated files

run_fix_test(
    name   => "Build using 'default.txt.fix' rule",
    exit   => 0,
    args   =>  [qw( 1.txt )],
    stats  => [[qw( 1.txt )]],
    source => {
        'default.txt.fix' => nl('echo $1',
                                'echo $2'),
    },
    result => {
        '1.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'default.txt.fix' ]],
            cont  => nl("$ENV{PWD}/1.txt--fixing",
                        "$ENV{PWD}/1.txt"),
        },
    },
);
rmtree([ ".$name", '1.txt', 'default.txt.fix' ]);  # erase generated files

run_fix_test(
    name   => "Build using 'default.fix' rule",
    exit   => 0,
    args   =>  [qw( 1.txt )],
    stats  => [[qw( 1.txt )]],
    source => {
        'default.fix' => nl('echo $1',
                            'echo $2'),
    },
    result => {
        '1.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'default.fix' ]],
            cont  => nl("$ENV{PWD}/1.txt--fixing",
                        "$ENV{PWD}/1.txt"),
        },
    },
);
rmtree([ ".$name", '1.txt', 'default.fix' ]);  # erase generated files

###############################################################################

note '=== Building without Explicit Dependencies ===';
enter_dir("greybox-no-explicit-deps");
write_file('.fixrc' => '');

rmtree([ '1', '1.fix' ]);  # erase generated files
run_fix_test(
    name   => "Buildscript outputting \$1 + \$2",
    exit   => 0,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo $1',
                      'echo $2'),
    },
    result => {
        '1' => {
            state => NEW_CONTENT,
            deps  => [[ '1.fix' ]],
            cont  => nl("$ENV{PWD}/1--fixing",
                        "$ENV{PWD}/1"),
        },
    },
);

run_fix_test(
    name   => "Rerun without changes",
    exit   => 0,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo $1',
                      'echo $2'),
    },
    result => {
        '1' => {
            state => UNCHANGED,
            deps  => [[ '1.fix' ]],
            cont  => nl("$ENV{PWD}/1--fixing",
                        "$ENV{PWD}/1"),
        },
    },
);

# (Won't generate tempfile, since build isn't attempted at all.)
write_file('1', nl('XXX'));                    # modify target file
run_fix_test(
    name   => "Rerun after target was externally modified",
    exit   => 253,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo $1',
                      'echo $2'),
    },
    result => {
        '1' => {
            abort => '1',
            state => WONT_OVERWR,
            deps  => [[ '1.fix' ]],
            cont  => nl("$ENV{PWD}/1--fixing",
                        "$ENV{PWD}/1"),
        },
    },
);

delete_file('1');
run_fix_test(
    name   => "Rerun after target was deleted",
    exit   => 0,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo $1',
                      'echo $2'),
    },
    result => {
        '1' => {
            state => REPL_ERASED,
            deps  => [[ '1.fix' ]],
            cont  => nl("$ENV{PWD}/1--fixing",
                        "$ENV{PWD}/1"),
        },
    },
);

run_fix_test(
    name   => "Rerun after buildscript was changed, but give same output",
    exit   => 0,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('# COMMENT',
                      'echo $1',
                      'echo $2'),
    },
    result => {
        '1' => {
            state => KEPT_PREV,
            deps  => [[ '1.fix' ]],
            cont  => nl("$ENV{PWD}/1--fixing",
                        "$ENV{PWD}/1"),
        },
    },
);

run_fix_test(
    name   => "Rerun after buildscript was changed, and give new output",
    exit   => 0,
    args   =>  [qw( 1 )],
    stats  => [[qw( 1 )]],
    source => {
        '1.fix' => nl('echo 1'),
    },
    result => {
        '1' => {
            state => NEW_CONTENT,
            deps  => [[ '1.fix' ]],
            cont  => nl('1'),
        },
    },
);

run_fix_test(
    name   => "Writing to tempfile explicitly (not STDOUT)",
    exit   => 0,
    args   =>  [qw( test.txt )],
    stats  => [[qw( test.txt )]],
    source => {
        'test.txt.fix' => nl('echo test >$1'),
    },
    result => {
        'test.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'test.txt.fix' ]],
            cont  => nl('test'),
        },
    },
);

###############################################################################

note '=== Source Dependencies ===';
enter_dir("greybox-source-deps");
write_file('.fixrc' => '');

run_fix_test(
    name   => "Non-existing target dependency",
    exit   => 255,
    args   =>  [qw( indented.txt )],
    stats  => [[qw( indented.txt )], [qw( NON-EXISTING-TARGET )]],
    source => {
        'indented.txt.fix' => nl('fix NON-EXISTING-TARGET'),
    },
    result => {
        'indented.txt' => {
            abort => 'NON-EXISTING-TARGET',
            state => BUILD_FAIL,
            deps  => [[ 'indented.txt.fix' ]],
        },
        'NON-EXISTING-TARGET' => {
            abort => 'NON-EXISTING-TARGET',
            state => NOT_FOUND,
        },
    },
);

run_fix_test(
    name   => "Non-existing source dependency",
    exit   => 255,
    args   =>  [qw( indented.txt )],
    stats  => [[qw( indented.txt )], [qw( --source NON-EXISTING-SOURCE )]],
    source => {
        'indented.txt.fix' => nl('fix --source NON-EXISTING-SOURCE'),
    },
    result => {
        'indented.txt' => {
            abort => 'NON-EXISTING-SOURCE',
            state => BUILD_FAIL,
            deps  => [[ 'indented.txt.fix' ]],
        },
        'NON-EXISTING-SOURCE' => {
            abort => 'NON-EXISTING-SOURCE',
            state => SRC_NOT_FOUND,
        },
    },
);

run_fix_test(
    name   => "Source dependency",
    exit   => 0,
    args   =>  [qw( indented.txt )],
    stats  => [[qw( indented.txt )], [qw( --source source.txt )]],
    source => {
        'indented.txt.fix' => nl('fix --source source.txt',
                                 'sed "s/^/> /" <source.txt'),
        'source.txt' => nl('some text'),
    },
    result => {
        'indented.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'indented.txt.fix' ], [ 'source.txt' ]],
            cont  => nl('> some text'),
        },
        'source.txt' => {
            type  => SOURCE,
            state => SRC_REGIST,
            cont  => nl('some text'),
        },
    },
);

run_fix_test(
    name   => "Source dependency, rebuild without change",
    exit   => 0,
    args   =>  [qw( indented.txt )],
    stats  => [[qw( indented.txt )]],
    source => {
        'indented.txt.fix' => nl('fix --source source.txt',
                                 'sed "s/^/> /" <source.txt'),
        'source.txt' => nl('some text'),
    },
    result => {
        'indented.txt' => {
            state => UNCHANGED,
            deps  => [[ 'indented.txt.fix' ], [ 'source.txt' ]],
            cont  => nl('> some text'),
        },
        'source.txt' => {
            type  => SOURCE,
            state => NO_RUNSTATE,
            cont  => nl('some text'),
        },
    },
);

run_fix_test(
    name   => "Source dependency, rebuild with source change",
    exit   => 0,
    args   =>  [qw( indented.txt )],
    stats  => [[qw( indented.txt )], [qw( --source source.txt )]],
    source => {
        'indented.txt.fix' => nl('fix --source source.txt',
                                 'sed "s/^/> /" <source.txt'),
        'source.txt' => nl('some other text'),
    },
    result => {
        'indented.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'indented.txt.fix' ], [ 'source.txt' ]],
            cont  => nl('> some other text'),
        },
        'source.txt' => {
            type  => SOURCE,
            state => SRC_REGIST,
            cont  => nl('some other text'),
        },
    },
);

###############################################################################

note '=== Checksum-Based Dependencies (a.txt -> b.txt) ===';
enter_dir("greybox-dep-checksums");
write_file('.fixrc' => '');

run_fix_test(
    name   => "Initial build from 'a.txt'",
    exit   => 0,
    args   =>  [qw( a.txt )],
    stats  => [[qw( a.txt )], [qw( b.txt )]],
    source => {
        'a.txt.fix' => nl('fix b.txt',
                          'echo "AAA"',
                          'sed "s/^/>/" <b.txt'),
        'b.txt.fix' => nl('echo "BBB"'),
    },
    result => {
        'a.txt' => {
            state => NEW_CONTENT,
            deps  => [['a.txt.fix'], ['b.txt']],
            cont  => nl('AAA',
                        '>BBB'),
        },
        'b.txt' => {
            state => NEW_CONTENT,
            deps  => [['b.txt.fix']],
            cont  => nl('BBB'),
        },
    },
);

run_fix_test(
    name   => "Rebuild of modified 'b.txt'",
    exit   => 0,
    args   =>  [qw( b.txt )],
    stats  => [[qw( b.txt )]],
    source => {
        'b.txt.fix' => nl('echo "BBB BBB"'),
    },
    result => {
        'b.txt' => {
            state => NEW_CONTENT,
            deps  => [['b.txt.fix']],
            cont  => nl('BBB BBB'),
        },
    },
);

# This will fail unless dependencies include checksums.
run_fix_test(
    name   => "Rebuild from 'a.txt'",
    exit   => 0,
    args   =>  [qw( a.txt )],
    stats  => [[qw( a.txt )], [qw( b.txt )]],
    source => {
        'a.txt.fix' => nl('fix b.txt',
                          'echo "AAA"',
                          'sed "s/^/>/" <b.txt'),
        'b.txt.fix' => nl('echo "BBB BBB"'),
    },
    result => {
        'a.txt' => {
            state => NEW_CONTENT,
            deps  => [['a.txt.fix'], ['b.txt']],
            cont  => nl('AAA',
                        '>BBB BBB'),
        },
        'b.txt' => {
            state => UNCHANGED,
            deps  => [['b.txt.fix']],
            cont  => nl('BBB BBB'),
        },
    },
);

###############################################################################

note '=== Target it Subdir ===';
enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => '');

mkdir('subdir') or die "cannot create dir 'subdir',";
run_fix_test(
    name   => "Building target in subdir",
    exit   => 0,
    args   =>  [qw( subdir/hello.txt )],
    stats  => [[qw( subdir/hello.txt )]],
    after  => sub {
        ok(! -e "subdir/.fix", "Statedir non-existing in subdir: subdir/.fix");
    },
    source => {
        'subdir/hello.txt.fix' => nl('echo "Hello, world!"'),
    },
    result => {
        'subdir/hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'subdir/hello.txt.fix' ]],
            cont  => nl("Hello, world!"),
        },
    },
);

enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => '');
run_fix_test(
    name   => "Building target from default buildscript",
    exit   => 0,
    args   =>  [qw( hello.txt )],
    stats  => [[qw( hello.txt )]],
    source => {
        'default.txt.fix' => nl('echo "Hello, world!"'),
    },
    result => {
        'hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'default.txt.fix' ]],
            cont  => nl("Hello, world!"),
        },
    },
);

enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => '');
mkdir('subdir') or die "cannot create dir 'subdir',";
run_fix_test(
    name   => "Building target from default buildscript in subdir",
    exit   => 0,
    args   =>  [qw( subdir/hello.txt )],
    stats  => [[qw( subdir/hello.txt )]],
    after  => sub {
        ok(! -e "subdir/.fix", "Statedir non-existing in subdir: subdir/.fix");
    },
    source => {
        'subdir/default.txt.fix' => nl('echo "Hello, world!"'),
    },
    result => {
        'subdir/hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'subdir/default.txt.fix' ]],
            cont  => nl("Hello, world!"),
        },
    },
);

enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => nl('[core]', 'scriptTree = cfg'));
run_fix_test(
    name   => "Building target from default buildscript with core.scriptTree",
    exit   => 0,
    args   =>  [qw( hello.txt )],
    stats  => [[qw( hello.txt )]],
    source => {
        'arg/default.txt.fix' => nl('echo argument'),
        'cfg/default.txt.fix' => nl('echo config'),
        'env/default.txt.fix' => nl('echo environment'),
    },
    result => {
        'hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'cfg/default.txt.fix' ]],
            cont  => nl("config"),
        },
    },
);

rmtree([ ".$name", 'hello.txt' ]);
run_fix_test(
    name   => "Building target with \$FIX_SCRIPT_TREE (overriding config file)",
    exit   => 0,
    args   =>  [qw( hello.txt )],
    stats  => [[qw( hello.txt )]],
    before => sub {        $ENV{FIX_SCRIPT_TREE} = 'env'  },
    after  => sub { delete $ENV{FIX_SCRIPT_TREE}          },
    source => {
        'arg/default.txt.fix' => nl('echo argument'),
        'cfg/default.txt.fix' => nl('echo config'),
        'env/default.txt.fix' => nl('echo environment'),
    },
    result => {
        'hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'env/default.txt.fix' ]],
            cont  => nl("environment"),
        },
    },
);

rmtree([ ".$name", 'hello.txt' ]);
run_fix_test(
    name   => "Building target with --script-tree " .
              "(overriding environment and config file)",
    exit   => 0,
    args   =>  [qw( --script-tree=arg hello.txt )],
    stats  => [[qw( --script-tree=arg hello.txt )]],
    before => sub {        $ENV{FIX_SCRIPT_TREE} = 'env'  },
    after  => sub { delete $ENV{FIX_SCRIPT_TREE}          },
    source => {
        'arg/default.txt.fix' => nl('echo argument'),
        'cfg/default.txt.fix' => nl('echo config'),
        'env/default.txt.fix' => nl('echo environment'),
    },
    result => {
        'hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'arg/default.txt.fix' ]],
            cont  => nl("argument"),
        },
    },
);

###############################################################################

enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => nl('[core]', 'scriptTree = fix'));
mkdir('subdir') or die "cannot create dir 'subdir',";
run_fix_test(
    name   => "Building target in subdir with core.scriptTree",
    exit   => 0,
    args   =>  [qw( subdir/hello.txt )],
    stats  => [[qw( subdir/hello.txt )]],
    after  => sub {
        ok(! -e "subdir/.fix", "Statedir non-existing in subdir: subdir/.fix");
    },
    source => {
        'fix/subdir/hello.txt.fix' => nl('echo "Hello, world!"'),
    },
    result => {
        'subdir/hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'fix/subdir/hello.txt.fix' ]],
            cont  => nl("Hello, world!"),
        },
    },
);

enter_dir("greybox-target-in-subdir");
write_file('.fixrc' => nl('[core]', 'scriptTree = fix'));
mkdir('subdir') or die "cannot create dir 'subdir',";
run_fix_test(
    name   => "Building target from default buildscript in subdir with " .
              "core.scriptTree",
    exit   => 0,
    args   =>  [qw( subdir/hello.txt )],
    stats  => [[qw( subdir/hello.txt )]],
    after  => sub {
        ok(! -e "subdir/.fix", "Statedir non-existing in subdir: subdir/.fix");
    },
    source => {
        'fix/subdir/default.txt.fix' => nl('echo "Hello, world!"'),
    },
    result => {
        'subdir/hello.txt' => {
            state => NEW_CONTENT,
            deps  => [[ 'fix/subdir/default.txt.fix' ]],
            cont  => nl("Hello, world!"),
        },
    },
);

###############################################################################

note '=== Multiple Dependencies ===';
enter_dir("greybox-multiple-deps");
write_file('.fixrc' => '');

run_fix_test(
    name   => "First run of buildscript with dependencies",
    exit   => 0,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )], [qw(ab 12)], [qw(a b)], [qw(1 2)]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 2'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => NEW_CONTENT,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>2 )),
        },
        ab => {
            state => NEW_CONTENT,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b             )),
        },
        12 => {
            state => NEW_CONTENT,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >2 )),
        },
        a => {
            state => NEW_CONTENT,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                 )),
        },
        b => {
            state => NEW_CONTENT,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b             )),
        },
        1 => {
            state => NEW_CONTENT,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1     )),
        },
        2 => {
            state => NEW_CONTENT,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           2 )),
        },
    },
);

run_fix_test(
    name   => "Rerun without change",
    exit   => 0,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 2'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => UNCHANGED,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>2 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b             )),
        },
        12 => {
            state => UNCHANGED,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >2 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                 )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b             )),
        },
        1 => {
            state => UNCHANGED,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1     )),
        },
        2 => {
            state => UNCHANGED,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           2 )),
        },
    },
);

run_fix_test(
    name   => "Rerun after change of subtarget '2'",
    exit   => 0,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )], [qw(1 2)], [qw(ab 12)]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 22'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => NEW_CONTENT,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        12 => {
            state => NEW_CONTENT,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        1 => {
            state => UNCHANGED,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        2 => {
            state => NEW_CONTENT,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

delete_file('12');
run_fix_test(
    name   => "Rerun after a dependency '12' was deleted",
    exit   => 0,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )], [qw(1 2)]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 22'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => UNCHANGED,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        12 => {
            state => REPL_ERASED,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        1 => {
            state => UNCHANGED,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        2 => {
            state => UNCHANGED,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

delete_file('1');
run_fix_test(
    name   => "Rerun after a dependency '1' was deleted",
    exit   => 0,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 22'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => UNCHANGED,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        12 => {
            state => UNCHANGED,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        1 => {
            state => REPL_ERASED,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        2 => {
            state => UNCHANGED,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

# (Won't generate tempfile, since build isn't attempted at all.)
# FIXME: When graceful abort is added, check runstate of NO_RUNSTATE targets.
write_file('1', nl('XXX'));                    # modify target file
run_fix_test(
    name   => "Rerun after dependency target '1' externally modified",
    exit   => 253,
    args   =>  [qw( ab12 )],
    stats  => [[qw( ab12 )]],
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 22'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => NO_RUNSTATE,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        12 => {
            state => NO_RUNSTATE,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        1 => {
            abort => '1',
            state => WONT_OVERWR,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        2 => {
            state => NO_RUNSTATE,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

###############################################################################

note '=== Target Outside Current Dir ===';
delete_file('1');

run_fix_test(
    name   => "Building target in parent dir",
    exit   => 0,
    args   =>  [qw( ../ab12 )],
    stats  => [[qw(    ab12 )]],
    before => sub {
        mkdir('abc') && chdir('abc') || die "cannot cd to 'abc',";
    },
    after  => sub {
        chdir('..')  || die "cannot cd back from 'abc',";
        ok(! -e "abc/.fix", "Statedir non-existing in subdir: abc/.fix");
    },
    source => {
        'ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        '12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'b.fix'    => nl('echo b'),
        'a.fix'    => nl('echo a'),
        '2.fix'    => nl('echo 22'),
        '1.fix'    => nl('echo 1'),
    },
    result => {
        ab12 => {
            state => UNCHANGED,
            deps  => [[ 'ab12.fix' ], [qw( ab 12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        ab => {
            state => UNCHANGED,
            deps  => [[ 'ab.fix' ], [qw( a  b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        12 => {
            state => UNCHANGED,
            deps  => [[ '12.fix' ], [qw( 1  2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        a => {
            state => UNCHANGED,
            deps  => [[ 'a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        b => {
            state => UNCHANGED,
            deps  => [[ 'b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        1 => {
            state => REPL_ERASED,
            deps  => [[ '1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        2 => {
            state => UNCHANGED,
            deps  => [[ '2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

run_fix_test(
    name   => "Building target in subdir",
    exit   => 0,
    args   =>  [qw( abc/ab12 )],
    stats  => [[qw( abc/ab12      )],
               [qw( abc/ab abc/12 )],
               [qw( abc/a  abc/b  )],
               [qw( abc/1  abc/2  )]],
    after  => sub {
        ok(! -e "abc/.fix", "Statedir non-existing in subdir: abc/.fix");
    },
    source => {
        'abc/ab12.fix' => nl('$FIX ab 12', 'echo ab12', 'cat ab 12 | sed "s/^/>/"'),
        'abc/ab.fix'   => nl('$FIX a b',   'echo ab',   'cat  a  b | sed "s/^/>/"'),
        'abc/12.fix'   => nl('$FIX 1 2',   'echo 12',   'cat  1  2 | sed "s/^/>/"'),
        'abc/b.fix'    => nl('echo b'),
        'abc/a.fix'    => nl('echo a'),
        'abc/2.fix'    => nl('echo 22'),
        'abc/1.fix'    => nl('echo 1'),
    },
    result => {
        'abc/ab12' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/ab12.fix' ], [qw( abc/ab abc/12 )]],
            cont  => nl(qw(ab12 >ab >>a >>b >12 >>1 >>22 )),
        },
        'abc/ab' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/ab.fix' ], [qw( abc/a  abc/b )]],
            cont  => nl(qw(      ab  >a  >b              )),
        },
        'abc/12' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/12.fix' ], [qw( abc/1  abc/2 )]],
            cont  => nl(qw(                  12  >1  >22 )),
        },
        'abc/a' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/a.fix' ]],
            cont  => nl(qw(           a                  )),
        },
        'abc/b' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/b.fix' ]],
            cont  => nl(qw(               b              )),
        },
        'abc/1' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/1.fix' ]],
            cont  => nl(qw(                       1      )),
        },
        'abc/2' => {
            state => NEW_CONTENT,
            deps  => [[ 'abc/2.fix' ]],
            cont  => nl(qw(                           22 )),
        },
    },
);

###############################################################################

chdir $Dir;
SKIP: {
    skip("\$VERSION test - since no .git dir was found", 1) unless -d '.git';
    # get latest major & minor version numbers from last version tag in git
    my ($major, $minor) = (`git tag -l 'v*'`)[-1] =~ m#^v(\d+)\.(\d+)\n$#;
    # patch number = number of commits since last version tag
    my $patch =()= `git log --follow --oneline "v$major.$minor".. fix`;
    # check if 'fix' has been modified since last commit
    my $modified = system("git diff --quiet HEAD fix");
    if ($modified) {
        my $expect1 = "$major.$minor." . ($patch + 1);
        my $expect2 = "$major." . ($minor + 1) . ".0";
        my $expect3 = ($major + 1) . ".0.0";
        ok($Local::Modulino::VERSION ~~ [$expect1, $expect2, $expect3],
            "fix \$VERSION number")
            or note
                "         got: '$Local::Modulino::VERSION'\n" .
                "    expected: '$expect1', '$expect2' or '$expect3'";
    } else {
        my $expect = "$major.$minor.$patch";
        is($Local::Modulino::VERSION, $expect, "fix \$VERSION number");
    }
}

###############################################################################

END {
    done_testing();
    note
        "================================================\n" .
        " NOTA BENE! EXIT STATEMENT FOUND IN TESTSCRIPT!\n" .
        "================================================\n"
            if $exit_statement_in_test_script;
}

#[eof]