Cross Reference: /illumos-gate/usr/src/cmd/logadm/tester

	tester revision 7ea027865de56bac0c639f5fe006cc752ce41413
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#!/usr/bin/perl -w
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# CDDL HEADER START
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# The contents of this file are subject to the terms of the
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# Common Development and Distribution License (the "License").
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# You may not use this file except in compliance with the License.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# or http://www.opensolaris.org/os/licensing.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# See the License for the specific language governing permissions
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# and limitations under the License.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# When distributing Covered Code, include this CDDL HEADER in each
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# If applicable, add the following below this CDDL HEADER, with the
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# fields enclosed by brackets "[]" replaced with your own identifying
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# information: Portions Copyright [yyyy] [name of copyright owner]
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# CDDL HEADER END
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# Copyright (c) 2013, Joyent, Inc. All rights reserved.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# tester - run logadm tests
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# requires a <bindir> argument to say where the various logadm
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# binaries live (conftest, globtest, kwtest, luttest, optstest, and
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# logadm itself).
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# to run all the tests:
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   tester [-f] <bindir>
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# to run just a few tests, given their names:
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   tester [-f] <bindir> globtest1 luttest1
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# to setup a test and stop so you can run it by hand:
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   tester [-f] -s globtest1 <bindir>
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   tester will tell you what tmp directory it created for
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   the test.  to run it, cd there and run:
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#       sh runtest
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#   to check the results, run:
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#       sh checktest
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# -f means "fast" -- without it, watchmalloc(3MALLOC) is setup for
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# each test and they run a zillion times slower and produce core
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# dumps when malloc/free problems are detected.
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont#
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont$watchmalloc=1;     # default is to use watchmalloc
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont${ENV} = "/bin";
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupontumask 002;
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont# list of tests we run by default
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont@tests = (
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "conftest1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "conftest2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "globtest1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "globtest2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "kwtest1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "kwtest2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "luttest1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "optstest1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "optstest2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadmV1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadmV2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadmr",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadmw",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm1",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm1c",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm2",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm3",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm4",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm5",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm6",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm7",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm8",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm9",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm9d",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm10",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm11",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm12",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm13",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm14",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm15",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm16",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm17",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm18",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm19",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm20",
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont    "logadm21"
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont);
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupont
b091b4bb803b830d2d5a9e71b6648b669655d7dcFrancis Dupontuse Getopt::Std;
use File::Find;

$usage_summary = '[-s test-name] [-d dir] bindir [test-name...]';
$usage_getopts = 'fd:s:';
%usage = (
    d=>'use dir for tests rather than creating one in /tmp',
    s=>'setup only, do not run test');

# spew usage message, plus any given message, and exit
sub usage {
    my $msg = shift;

    if ($msg) {
        chomp $msg;
        warn "$0: $msg\n" if $msg;
    }
    warn "Usage: $0 $usage_summary\n";
    foreach (sort keys %usage) {
        warn "       -$_ $usage{$_}\n";
    }
    exit 1;
}

#
# basic argument processing
#
$myname = $0;
$myname =~ s/.*\///;    # just show last component in error mesages
getopts($usage_getopts) or usage;
$bindir = shift or usage;
usage("$bindir does not exist") unless -d $bindir;
usage("cannot list more than one test with -s option") if $opt_s && @ARGV;
@tests = @ARGV if @ARGV;
print "Fast mode\n" if $opt_f;
$watchmalloc = 0 if $opt_f;

$mydir=`pwd`;
chomp $mydir;

$dir = $opt_d;
$dir = "/tmp/logadmtest$$" unless $dir = $opt_d;

if (!-d $dir) {
    mkdir $dir, 0777 or die "$myname: mkdir $dir: $!\n";
    $needrmdir = 1;
}

chdir $dir or die "$myname: $dir: $!\n";

# common commands in runtest by tests
if ($watchmalloc) {
    $envsetup =
        "HOME=$dir export HOME; " .
        "LD_PRELOAD=watchmalloc.so.1 export LD_PRELOAD; " .
        "MALLOC_DEBUG=RW export MALLOC_DEBUG";
} else {
    $envsetup = "HOME=$dir export HOME; ";
}

$| = 1;     # a.k.a. setbuf(stdout, NULL)

if ($opt_s) {
    #
    # just setup the test, explain how to use it, and exit
    #
    $testname = $opt_s;
    eval "&$opt_s";
    die "$myname: ERROR: $@" if $@;
    print "$myname: $testname setup complete, to run, cd to:\n";
    print "    $dir\n";
    print "and run the command:\n";
    print "    sh runtest\n";
    print "to check the results, run the command:\n";
    print "    sh checktest\n";
    exit 0;
} else {
    #
    # run all the tests
    #
    foreach (@tests) {
        $testname = $_;
        print "Running $testname...";
        eval "&$_";
        if ($@) {
            print " SETUP FAILURE\n";
            print STDERR "$myname: ERROR: $@";
            exit 1;
        }
        eval "runner('runtest')";
        if ($@) {
            print " RUNTEST FAILURE\n";
            print STDERR "$myname: ERROR: $@";
            print STDERR "results captured in directory $dir\n";
            print STDERR "  or use: $myname -s $testname $bindir\n";
            print STDERR "  to do a fresh setup of this test.\n";
            exit 1;
        }
        eval "runner('checktest', '-x', '> checktest.out 2>&1')";
        if ($@) {
            print " CHECKTEST FAILURE\n";
            print STDERR "$myname: ERROR: $@";
            print STDERR "results captured in file $dir/checktest.out\n";
            print STDERR "  or use: $myname -s $testname $bindir\n";
            print STDERR "  to do a fresh setup of this test.\n";
            exit 1;
        }
        print "pass\n";
        # sanity...
        die "unexpected dir $dir" unless $dir =~ m,/.+/,;
        system("/bin/rm -rf $dir/*");
    }
}

# if we were the ones who created $dir, remove it
if ($needrmdir) {
    chdir $mydir;
    rmdir $dir || die "$myname: rmdir $dir: $!\n";
}

exit 0;

#
# run a shell script and check for failure
#
# the shell scripts generated by this program always "exec" the binary
# under test so checking here are for exit code, signals, and core dump
# is actually checking the program under test and not /bin/sh
#
sub runner {
    my ($cmd, $prefix, $suffix) = (@_, '', '');

    my $fullcmd = "/bin/sh $prefix $cmd $suffix";
    my $rc = 0xffff & system("$fullcmd");

    if ($rc == 0) {
        return;     # cmd completed normally
    } elsif ($rc == 0xff00) {
        die "command \"$cmd\" failed: $!\n";
    } elsif (($rc & 0xff) == 0) {
        $rc >>= 8;
        die "command \"$cmd\" exit $rc\n";
    } else {
        my $coremsg;
        $coremsg = " (core dumped)" if ($rc & 0x80);
        $rc &= ~0x80;
        die "command \"$cmd\" signal $rc$coremsg\n" ;
    }
}

#
# set_file(filename [, contents]) -- create a file, optionally with contents
#
sub set_file {
    my $file = shift;
    my $contents = shift;

    open SF, ">$file" or die "create \"$file\": $!\n";
    print SF $contents if defined($contents);
    close SF;
}

#############
#############
#############    THE TESTS START AFTER HERE...
#############
#############

# common setup step -- create a testfile.conf
sub set_testconffile {
    my $fname = shift;
    $fname = 'testfile.conf' unless defined($fname);

    set_file($fname, <<'EOF');
#
# logadm.conf
#
# Default settings for system log file management.
# The -w option to logadm(1M) is the preferred way to write to this file,
# but if you do edit it by hand, use "logadm -V" to check it for errors.
#
# The format of lines in this file is:
#       <logname> <options>
# For each logname listed here, the default options to logadm
# are given.  Options given on the logadm command line override
# the defaults contained in this file.
#
# logadm typically runs early every morning via an entry in
# root's crontab (see crontab(1)).
#
/var/adm/messages -C 4 -P 'Thu Nov  1 16:56:42 2001' -a 'kill -HUP `cat /var/run/*syslog*pid`'
/var/cron/log -s 512k -t /var/cron/olog
/var/lp/logs/lpsched -C 2 -N -t '$file.$N'
#
# The entry below is used by turnacct(1M)
#
/var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
apache -C 24 -a '/usr/apache/bin/apachectl graceful' -p 1m -t '/var/apache/old-logs/$basename.%Y-%m' '/var/apache/logs/*{access,error}_log'
/var/log/syslog -C 8 -P 'Thu Nov  1 09:16:38 2001' -a 'kill -HUP `cat /var/run/*syslog*pid`'
/var/apache/logs/access_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/error_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/suexec_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/mod_jserv.log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/jserv.log -P 'Thu Nov  1 08:27:56 2001'
EOF
}


###########################################################################
#
#   conftest1 -- minimal basic test of the conf.c code
#
###########################################################################
sub conftest1 {
    set_testconffile;

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
/bin/sed '/^conffile <testfile.conf>:$/d' <std.out >sed.out
exec /bin/diff testfile.conf sed.out
EOF

    set_file('runtest', <<"EOF");
# test "conftest1"
$envsetup
exec $bindir/conftest testfile.conf >std.out 2>std.err
EOF
}

###########################################################################
#
#   conftest2 -- error path through conf.c
#
###########################################################################
sub conftest2 {
    set_file('testfile.conf', 'line fragment');

    set_file('std.err.expect', <<'EOF');
conftest: Warning: file testfile.conf doesn't end with newline, last line ignored.
EOF

    set_file('checktest', <<'EOF');
exec /bin/diff std.err.expect std.err
EOF

    set_file('runtest', <<"EOF");
# test "conftest2"
$envsetup
$bindir/conftest testfile.conf >std.out 2>std.err || exit 0
exit 1
EOF
}

###########################################################################
#
#   globtest1 -- minimal basic test of the glob.c code
#
###########################################################################
sub globtest1 {
    set_file('fileBname12');
    sleep 2;    # ensure above name is odler than below name
    set_file('fileAname12');
    set_file('fileAname1');
    set_file('fileAname3');
    set_file('fileAname5');
    set_file('fileAname7');
    set_file('fileAname9');
    set_file('fileAname11');
    set_file('fileBname0');
    set_file('fileBname2');
    set_file('fileBname4');
    set_file('fileBname6');
    set_file('fileBname8');
    set_file('fileBname10');
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    mkdir 'dir3', 0777 or die "mkdir dir3: $!\n";
    mkdir 'dir1/dirA', 0777 or die "mkdir dir1/dirA: $!\n";
    mkdir 'dir1/dirB', 0777 or die "mkdir dir1/dirB: $!\n";
    mkdir 'dir1/dirC', 0777 or die "mkdir dir1/dirC: $!\n";
    mkdir 'dir2/dirA', 0777 or die "mkdir dir2/dirA: $!\n";
    mkdir 'dir2/dirB', 0777 or die "mkdir dir2/dirB: $!\n";
    mkdir 'dir2/dirC', 0777 or die "mkdir dir2/dirC: $!\n";
    set_file('dir1/fileAname1');
    set_file('dir1/fileAname2');
    set_file('dir1/fileAname3');
    set_file('dir1/fileAname4');
    set_file('dir1/fileAname5');
    set_file('dir1/fileBname1');
    set_file('dir1/fileBname2');
    set_file('dir1/fileBname3');
    set_file('dir1/fileBname4');
    set_file('dir1/fileBname5');
    # supply some varying sizes to produce different total size values
    set_file('dir1/dirA/fileAname4', '4444');
    sleep 2;    # ensure above file is oldest in dirA
    set_file('dir1/dirA/fileAname1', '1');
    set_file('dir1/dirA/fileAname2', '22');
    set_file('dir1/dirA/fileAname3', '333');
    set_file('dir1/dirA/fileAname5', '55555');
    set_file('dir1/dirA/fileBname1', '1');
    set_file('dir1/dirA/fileBname2', '22');
    set_file('dir1/dirA/fileBname3', '333');
    set_file('dir1/dirA/fileBname4', '4444');
    set_file('dir1/dirA/fileBname5', '55555');
    set_file('dir1/dirB/fileAname1', '1');
    set_file('dir1/dirB/fileAname2', '22');
    set_file('dir1/dirB/fileAname3', '333');
    set_file('dir1/dirB/fileAname4', '4444');
    set_file('dir1/dirB/fileAname5', '55555');
    set_file('dir1/dirB/fileBname1', '1');
    set_file('dir1/dirB/fileBname2', '22');
    set_file('dir1/dirB/fileBname3', '333');
    set_file('dir1/dirB/fileBname4', '4444');
    set_file('dir1/dirB/fileBname5', '55555');
    set_file('dir1/dirC/fileAname10', '12345678901');
    set_file('dir1/dirC/fileAname20', '123456789022');
    set_file('dir1/dirC/fileAname30', '1234567890333');
    set_file('dir1/dirC/fileAname40', '12345678904444');
    set_file('dir1/dirC/fileAname50', '123456789055555');
    set_file('dir1/dirC/fileBname10', '12345678901');
    set_file('dir1/dirC/fileBname20', '123456789022');
    set_file('dir1/dirC/fileBname30', '1234567890333');
    set_file('dir1/dirC/fileBname40', '12345678904444');
    set_file('dir1/dirC/fileBname50', '123456789055555');

    set_file('std.out.expect', <<'EOF');
<file{A,B,C}name*>:
    <./fileAname12>
    <./fileAname1>
    <./fileAname3>
    <./fileAname5>
    <./fileAname7>
    <./fileAname9>
    <./fileAname11>
    <./fileBname12>
    <./fileBname0>
    <./fileBname2>
    <./fileBname4>
    <./fileBname6>
    <./fileBname8>
    <./fileBname10>
total size: 0
    oldest <./fileBname12>
    oldest <./fileBname8>
    oldest <./fileBname6>
    oldest <./fileBname4>
    oldest <./fileBname2>
    oldest <./fileBname10>
    oldest <./fileBname0>
    oldest <./fileAname9>
    oldest <./fileAname7>
    oldest <./fileAname5>
    oldest <./fileAname3>
    oldest <./fileAname12>
    oldest <./fileAname11>
    oldest <./fileAname1>
<file{A,B,C}name>:
    <fileAname>
    <fileBname>
    <fileCname>
total size: 0
    oldest <fileCname>
    oldest <fileBname>
    oldest <fileAname>
<dir1/dirA/file*>:
    <./dir1/dirA/fileAname4>
    <./dir1/dirA/fileAname1>
    <./dir1/dirA/fileAname2>
    <./dir1/dirA/fileAname3>
    <./dir1/dirA/fileAname5>
    <./dir1/dirA/fileBname1>
    <./dir1/dirA/fileBname2>
    <./dir1/dirA/fileBname3>
    <./dir1/dirA/fileBname4>
    <./dir1/dirA/fileBname5>
total size: 30
    oldest <./dir1/dirA/fileAname4>
    oldest <./dir1/dirA/fileBname5>
    oldest <./dir1/dirA/fileBname4>
    oldest <./dir1/dirA/fileBname3>
    oldest <./dir1/dirA/fileBname2>
    oldest <./dir1/dirA/fileBname1>
    oldest <./dir1/dirA/fileAname5>
    oldest <./dir1/dirA/fileAname3>
    oldest <./dir1/dirA/fileAname2>
    oldest <./dir1/dirA/fileAname1>
<dir[13]/[e-z]*>:
    <./dir1/fileAname1>
    <./dir1/fileAname2>
    <./dir1/fileAname3>
    <./dir1/fileAname4>
    <./dir1/fileAname5>
    <./dir1/fileBname1>
    <./dir1/fileBname2>
    <./dir1/fileBname3>
    <./dir1/fileBname4>
    <./dir1/fileBname5>
total size: 0
    oldest <./dir1/fileBname5>
    oldest <./dir1/fileBname4>
    oldest <./dir1/fileBname3>
    oldest <./dir1/fileBname2>
    oldest <./dir1/fileBname1>
    oldest <./dir1/fileAname5>
    oldest <./dir1/fileAname4>
    oldest <./dir1/fileAname3>
    oldest <./dir1/fileAname2>
    oldest <./dir1/fileAname1>
<dir?/dir[AC]/fileBname[2-9]>:
    <./dir1/dirA/fileBname2>
    <./dir1/dirA/fileBname3>
    <./dir1/dirA/fileBname4>
    <./dir1/dirA/fileBname5>
total size: 14
    oldest <./dir1/dirA/fileBname5>
    oldest <./dir1/dirA/fileBname4>
    oldest <./dir1/dirA/fileBname3>
    oldest <./dir1/dirA/fileBname2>
<file[A-Z]n.*e([0-9]+)$0>:
    <./fileBname12>
    <./fileAname12>
    <./fileAname1>
    <./fileAname3>
    <./fileAname5>
    <./fileAname7>
    <./fileAname9>
    <./fileAname11>
    <./fileBname0>
    <./fileBname2>
    <./fileBname4>
    <./fileBname6>
    <./fileBname8>
    <./fileBname10>
total size: 0
    oldest <./fileBname12>
    oldest <./fileAname12>
    oldest <./fileAname11>
    oldest <./fileBname10>
    oldest <./fileAname9>
    oldest <./fileBname8>
    oldest <./fileAname7>
    oldest <./fileBname6>
    oldest <./fileAname5>
    oldest <./fileBname4>
    oldest <./fileAname3>
    oldest <./fileBname2>
    oldest <./fileAname1>
    oldest <./fileBname0>
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
exec /bin/diff std.out.expect std.out
EOF

    $testglobs='\'file{A,B,C}name*\' \'file{A,B,C}name\' \'dir1/dirA/file*\' \'dir[13]/[e-z]*\' \'dir?/dir[AC]/fileBname[2-9]\' -r \'file[A-Z]n.*e([0-9]+)$0\'';

    set_file('runtest', <<"EOF");
# test "globtest1"
$envsetup
exec $bindir/globtest $testglobs >std.out 2>std.err
EOF
}

###########################################################################
#
#   globtest2 -- error path through glob.c
#
###########################################################################
sub globtest2 {
    set_file('std.err.expect', <<'EOF');
globtest: Error: Missing }
EOF

    set_file('checktest', <<'EOF');
exec /bin/diff std.err.expect std.err
EOF

    set_file('runtest', <<"EOF");
# test "globtest2"
$envsetup
$bindir/globtest 'hello{there' >std.out 2>std.err || exit 0
exit 1
EOF
}

###########################################################################
#
#   kwtest1 -- minimal basic test of the kw.c code
#
###########################################################################
sub kwtest1 {
    $domainname = `/bin/domainname`; chomp $domainname;
    $isa = `/bin/uname -p`; chomp $isa;
    $platform = `/bin/uname -i`; chomp $platform;
    $nodename = `/bin/uname -n`; chomp $nodename;
    $machine = `/bin/uname -m`; chomp $machine;
    $release = `/bin/uname -r`; chomp $release;
    # /bin/zonename is in SUNWzoneu and so may not be present
    if (-f "/bin/zonename") {
        $zonename = `/bin/zonename`; chomp $zonename;
    } else {
        $zonename = "global";
    }
$secondblob=<<'EOF';
expand<$file.$n> n -1 hasn 1 result </var/log/syslog\.([0-9]+)$0>
expand<$file.$n> n 0 hasn 1 result </var/log/syslog.0>
expand<$file.$n> n 1 hasn 1 result </var/log/syslog.1>
expand<moose%d.$n> n -1 hasn 1 result <moose[0-9]+\.([0-9]+)$0>
expand<moose%d.$n> n 0 hasn 1 result <moose%d.0>
expand<moose%d.$n> n 1 hasn 1 result <moose%d.1>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n -1 hasn 1 result </var/logs-[0-9]+/moose-ISAporklips[0-9]+\.([0-9]+)$0>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n 0 hasn 1 result </var/logs-%Y/moose-ISAporklips%d.0>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n 1 hasn 1 result </var/logs-%Y/moose-ISAporklips%d.1>
EOF
    $percentd = `/bin/env TZ=UTC /bin/date +%d`; chomp $percentd;
    $percentY = `/bin/env TZ=UTC /bin/date +%Y`; chomp $percentY;
    $secondblob =~ s/%d/$percentd/mg;
    $secondblob =~ s/%Y/$percentY/mg;
    $secondblob =~ s/ISA/$isa/mg;
    $utcenv = "TZ=UTC export TZ";
    chomp $secondblob;
    set_file('sed.out.expect', <<"EOF");
            basename syslog
             dirname /var/log
              domain $domainname
                file /var/log/syslog
                home $dir
                 isa $isa
             logname $ENV{LOGNAME}
             machine $machine
               nfile
            nodename $nodename
            platform $platform
             release $release
                user $ENV{USER}
            zonename $zonename
$secondblob
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
/bin/sed -e '/^ *secs [0-9][0-9]*$/d'\
    -e "s/%d/`/bin/env TZ=UTC /bin/date +%d`/g"\
    -e "s/%Y/`/bin/env TZ=UTC /bin/date +%Y`/g"\
    <std.out >sed.out
exec /bin/diff sed.out.expect sed.out
EOF

    $kwtest='kwtest /var/log/syslog \'$file.$n\' \'moose%d.$n\' \'/var/logs-%Y/moose-$isa$#porklips%d.$n\'';
    set_file('runtest', <<"EOF");
# test "kwtest1"
$envsetup
$utcenv
exec $bindir/$kwtest >std.out 2>std.err
EOF
}

###########################################################################
#
#   kwtest2 -- NULL environment variables test of the kw.c code
#
###########################################################################
sub kwtest2 {
    $domainname = `/bin/domainname`; chomp $domainname;
    $isa = `/bin/uname -p`; chomp $isa;
    $platform = `/bin/uname -i`; chomp $platform;
    $nodename = `/bin/uname -n`; chomp $nodename;
    $machine = `/bin/uname -m`; chomp $machine;
    $release = `/bin/uname -r`; chomp $release;
    # /bin/zonename is in SUNWzoneu and so may not be present
    if (-f "/bin/zonename") {
        $zonename = `/bin/zonename`; chomp $zonename;
    } else {
        $zonename = "global";
    }
$secondblob=<<'EOF';
expand<$file.$n> n -1 hasn 1 result </var/log/syslog\.([0-9]+)$0>
expand<$file.$n> n 0 hasn 1 result </var/log/syslog.0>
expand<$file.$n> n 1 hasn 1 result </var/log/syslog.1>
expand<moose%d.$n> n -1 hasn 1 result <moose[0-9]+\.([0-9]+)$0>
expand<moose%d.$n> n 0 hasn 1 result <moose%d.0>
expand<moose%d.$n> n 1 hasn 1 result <moose%d.1>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n -1 hasn 1 result </var/logs-[0-9]+/moose-ISAporklips[0-9]+\.([0-9]+)$0>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n 0 hasn 1 result </var/logs-%Y/moose-ISAporklips%d.0>
expand</var/logs-%Y/moose-$isa$#porklips%d.$n> n 1 hasn 1 result </var/logs-%Y/moose-ISAporklips%d.1>
EOF
    $percentd = `/bin/env TZ=UTC /bin/date +%d`; chomp $percentd;
    $percentY = `/bin/env TZ=UTC /bin/date +%Y`; chomp $percentY;
    $secondblob =~ s/%d/$percentd/mg;
    $secondblob =~ s/%Y/$percentY/mg;
    $secondblob =~ s/ISA/$isa/mg;
    chomp $secondblob;
    set_file('sed.out.expect', <<"EOF");
            basename syslog
             dirname /var/log
              domain $domainname
                file /var/log/syslog
                home
                 isa $isa
             logname
             machine $machine
               nfile
            nodename $nodename
            platform $platform
             release $release
                user
            zonename $zonename
$secondblob
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
/bin/sed -e '/^ *secs [0-9][0-9]*$/d'\
    -e "s/%d/`/bin/env TZ=UTC /bin/date +%d`/g"\
    -e "s/%Y/`/bin/env TZ=UTC /bin/date +%Y`/g"\
    <std.out >sed.out
exec /bin/diff sed.out.expect sed.out
EOF

    $kwtest='kwtest /var/log/syslog \'$file.$n\' \'moose%d.$n\' \'/var/logs-%Y/moose-$isa$#porklips%d.$n\'';
    set_file('runtest', <<"EOF");
# test "kwtest2"
$envsetup
LOGNAME=
export LOGNAME
HOME=
export HOME
USER=
export USER
TZ=UTC
export TZ
exec $bindir/$kwtest >std.out 2>std.err
EOF
}

###########################################################################
#
#   luttest1 -- minimal basic test of the lut.c code
#
###########################################################################
sub luttest1 {
    set_file('std.out.expect', <<'EOF');
lut contains:
<fix> <NULL> (<NULL>)
<one> <two> (<two>)
<seven> <eight> (<eight>)
<six> <NULL> (<NULL>)
<three> <four> (<four>)
dup lut contains:
<fix> <NULL> (<NULL>)
<one> <two> (<two>)
<seven> <eight> (<eight>)
<six> <NULL> (<NULL>)
<three> <four> (<four>)
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
exec /bin/diff std.out.expect std.out
EOF

    set_file('runtest', <<"EOF");
# test "luttest1"
$envsetup
exec $bindir/luttest one=two three=four fix six seven=eight >std.out 2>std.err
EOF
}

###########################################################################
#
#   optstest1 -- minimal basic test of the opts.c code
#
###########################################################################
sub optstest1 {
    $options="-a -b moose -c 1h -d 'Fri Nov  2 13:19:55 2001' -e 1k -f 2 one two three";
    set_file('std.out.expect', <<"EOF");
options: $options
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
exec /bin/diff std.out.expect std.out
EOF

    set_file('runtest', <<"EOF");
# test "optstest1"
$envsetup
exec $bindir/optstest $options >std.out 2>std.err
EOF
}

###########################################################################
#
#   optstest2 -- error path through opts.c code
#
###########################################################################
sub optstest2 {
    $options="-a -b -c 1h -d 'Fri Nov  2 13:19:55 2001' -e 1k -f 2 one two three";
    set_file('std.err.expect', <<'EOF');
optstest: Error: Option 'b' requires an argument
optstest: Error: opts parsing failed
EOF

    set_file('checktest', <<'EOF');
[ -s std.out ] && exit 1
exec /bin/diff std.err.expect std.err
EOF

    set_file('runtest', <<"EOF");
# test "optstest2"
$envsetup
$bindir/optstest $options >std.out 2>std.err || exit 0
exit 1
EOF
}

###########################################################################
#
#   logadmV1 -- test of "logadm -V"
#
###########################################################################
sub logadmV1 {
    set_testconffile;

    set_file('std.out.expect', <<'EOF');
/var/adm/messages -C 4 -P 'Thu Nov  1 16:56:42 2001' -a 'kill -HUP `cat /var/run/*syslog*pid`'
/var/cron/log -s 512k -t /var/cron/olog
/var/lp/logs/lpsched -C 2 -N -t '$file.$N'
/var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
apache -C 24 -a '/usr/apache/bin/apachectl graceful' -p 1m -t '/var/apache/old-logs/$basename.%Y-%m' '/var/apache/logs/*{access,error}_log'
/var/log/syslog -C 8 -P 'Thu Nov  1 09:16:38 2001' -a 'kill -HUP `cat /var/run/*syslog*pid`'
/var/apache/logs/access_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/error_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/suexec_log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/mod_jserv.log -P 'Thu Nov  1 08:27:56 2001'
/var/apache/logs/jserv.log -P 'Thu Nov  1 08:27:56 2001'
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
exec /bin/diff std.out.expect std.out
EOF

    set_file('runtest', <<"EOF");
# test "logadmV1"
$envsetup
exec $bindir/logadm -f testfile.conf -F testfile.conf -V >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadmV2 -- test of "logadm -V <entry>"
#
###########################################################################
sub logadmV2 {
    set_testconffile;

    set_file('std.out.expect', <<'EOF');
/var/cron/log -s 512k -t /var/cron/olog
/var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
exec /bin/diff std.out.expect std.out
EOF

    set_file('runtest', <<"EOF");
# test "logadmV2"
$envsetup
exec $bindir/logadm -f testfile.conf -F testfile.conf -V /var/cron/log /var/adm/pacct >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadmr -- test of "logadm -r <entry>"
#
###########################################################################
sub logadmr {
    set_testconffile;
    set_testconffile('testfile.conf.orig');

    set_file('diff.out.expect', <<'EOF');
18d17
< /var/cron/log -s 512k -t /var/cron/olog
23d21
< /var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
/bin/diff testfile.conf.orig testfile.conf > diff.out
exec /bin/diff diff.out.expect diff.out
EOF

    set_file('runtest', <<"EOF");
# test "logadmr"
$envsetup
exec $bindir/logadm -f testfile.conf -F testfile.conf -r /var/cron/log /var/adm/pacct >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadmw -- test of "logadm -w <entry>"
#
###########################################################################
sub logadmw {
    set_testconffile;
    set_testconffile('testfile.conf.orig');

    set_file('diff.out.expect', <<'EOF');
30a31
> moose -C 20 -a moose_after_cmd -g pig -m 664 -o cow -p never /moose/file
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
/bin/diff testfile.conf.orig testfile.conf > diff.out
exec /bin/diff diff.out.expect diff.out
EOF

    set_file('runtest', <<"EOF");
# test "logadmw"
$envsetup
exec $bindir/logadm -f testfile.conf -F testfile.conf -w moose -C 20 -a moose_after_cmd -g pig -m 664 -o cow -p never /moose/file >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm1 -- minimal basic test of logadm rotation
#
###########################################################################
sub logadm1 {
    set_file('logfile', 'initially logfile');
    set_file('logfile.0', 'initially logfile.0');
    my ($stdev, $stino, $stmode, $stnlink, $stuid, $stgid, $strdev,
        $stsize, $statime, $stmtime, $stctime, $stblksize, $stblocks) =
        lstat 'logfile' or die "lstat logfile: $!\n";

    set_file('checktest', <<"EOF");
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ "`/bin/ls -i logfile.0 | /bin/awk '{ print \$1; }'`" = "$stino" ] || exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.1`" ] || exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm1"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm1c -- same as logadm1 but with -c option
#
###########################################################################
sub logadm1c {
    set_file('logfile', 'initially logfile');
    set_file('logfile.0', 'initially logfile.0');
    my ($stdev, $stino, $stmode, $stnlink, $stuid, $stgid, $strdev,
        $stsize, $statime, $stmtime, $stctime, $stblksize, $stblocks) =
        lstat 'logfile' or die "lstat logfile: $!\n";

    set_file('checktest', <<"EOF");
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ "`/bin/ls -i logfile.0 | /bin/awk '{ print \$1; }'`" = "$stino" ] && exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.1`" ] || exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm1c"
$envsetup
exec $bindir/logadm -f /dev/null -p now -c logfile >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm2 -- minimal basic test of logadm expiration
#
###########################################################################
sub logadm2 {
    set_file('logfile', 'initially logfile');
    set_file('logfile.0', 'initially logfile.0');
    set_file('logfile.1', 'initially logfile.1');

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.1`" ] || exit 1
[ -f logfile.2 ] && exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm2"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile -C2 >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm3 -- minimal basic test of logadm pre/post-commands
#
###########################################################################
sub logadm3 {
    set_file('logfile', 'initially logfile');
    set_file('logfile.0', 'initially logfile.0');
    set_file('logfile.1', 'initially logfile.1');

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.1`" ] || exit 1
[ -f logfile.2 ] && exit 1
[ -f pre.out ] || exit 1
[ "xpre-command-stuff" = "x`/bin/cat pre.out`" ] || exit 1
[ -f post.out ] || exit 1
[ "xpost-command-stuff" = "x`/bin/cat post.out`" ] || exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm3"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile -C2 -b 'echo pre-command-stuff > pre.out' -a 'echo post-command-stuff > post.out' >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm4 -- test of -t template
#
###########################################################################
sub logadm4 {
    set_file('logfile', 'initially logfile');

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
TZ=UTC export TZ
d=`/bin/date +%d`
[ -f logfile.$d ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.$d`" ] || exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm4"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile -t '\$file.\%d' >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm5 -- test of -R cmd and -E cmd
#
###########################################################################
sub logadm5 {
    set_file('logfile', 'initially logfile');
    set_file('logfile.0', 'initially logfile.0');

    set_file('cmd.out.expect', <<'EOF');
just rotated: initially logfile
just expired: initially logfile.0
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.1`" ] || exit 1
exec /bin/diff cmd.out.expect cmd.out
EOF

    set_file('runtest', <<"EOF");
# test "logadm5"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile -C1 -R 'echo just rotated: `/bin/cat \$file` >>cmd.out' -E 'echo just expired: `/bin/cat \$file` >>cmd.out' >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm6 -- test of -m, -o, -g
#
###########################################################################
sub logadm6 {
        set_file('logfile', 'initially logfile');

        set_file('std.err.expect', <<'EOF');
logadm: Warning: command failed: /bin/chown _nonexistentuser_:_nonexistentgroup_ logfile
chown: unknown group id _nonexistentgroup_
EOF

        set_file('checktest', <<'EOF');
[ -s std.err ] || exit 1;
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.0`" ] || exit 1
[ "`/bin/ls -l logfile | /bin/awk '{ print $1; }'`" = "-r----x--x" ] || exit 1
exec /bin/diff std.err.expect std.err
EOF

        set_file('runtest', <<"EOF");
# test "logadm6"
$envsetup
exec $bindir/logadm -f /dev/null -p now logfile -m 411 -o _nonexistentuser_ -g _nonexistentgroup_ >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm7 -- test running through a conffile
#
###########################################################################
sub logadm7 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');

    set_file('logadm.conf', <<'EOF');
#
# logadm.conf
#
#   this comment # has at least another #-sign in it #...
#
# Default settings for system log file management.
# The -w option to logadm(1M) is the preferred way to write to this file,
# but if you do edit it by hand, use "logadm -V" to check it for errors.
# but if you do edit it by hand, use "logadm -V" to check it for errors.
#
# The format of lines in this file is:
#       <logname> <options>
# For each logname listed here, the default options to logadm
# are given.  Options given on the logadm command line override
# the defaults contained in this file.
#
# logadm typically runs early every morning via an entry in
# root's crontab (see crontab(1)).
#
dir1/syslog -C 8 -a 'echo kill -HUP `cat /var/run/*syslog*pid` >> cmd.out'
dir2/messages -C 4 -a 'echo kill -HUP `cat /var/run/*syslog*pid` >> cmd.out'
#
# The entry below is used by turnacct(1M)
#
/var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
EOF

    system("/bin/cp logadm.conf logadm.conf.orig");

    $pid=`cat /var/run/*syslog*pid`;
    chomp $pid;
    set_file('cmd.out.expect', <<"EOF");
kill -HUP $pid
second kill -HUP $pid
EOF

    set_file('sed.out.expect', <<'EOF');
# This file holds internal data for logadm(1M).
# Do not edit.
dir1/syslog
dir2/messages
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logadm.timestamps ] || exit 1
[ -s std.err2 ] && exit 1
[ -s std.out2 ] && exit 1
[ -s std.err3 ] && exit 1
[ -s std.out3 ] && exit 1
[ -s std.err4 ] && exit 1
[ -s std.out4 ] && exit 1
[ -f dir1/syslog ] || exit 1
[ "xsomething" = "x`/bin/cat dir1/syslog`" ] || exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -s dir2/messages ] && exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xsomething" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.3`" ] || exit 1
[ -f dir2/messages.4 ] && exit 1
/bin/sed "s/ -P '[^']*' *//" < logadm.timestamps > sed.out
/bin/diff sed.out.expect sed.out || exit 1
exec /bin/diff logadm.conf.orig logadm.conf
EOF

        # first logadm call will rotate both syslog and messages
        # second one won't because size is zero
        # third one won't because of -P timestamps stored in conffile
        # fourth one will do messages because of -p now on command line
        set_file('runtest', <<"EOF");
# test "logadm7"
$envsetup
$bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err || exit 1
$bindir/logadm -f logadm.conf -F logadm.timestamps dir1/syslog dir2/messages >std.out2 2>std.err2 || exit 1
echo something > dir1/syslog
echo something > dir2/messages
$bindir/logadm -f logadm.conf -F logadm.timestamps >std.out3 2>std.err3 || exit 1
exec $bindir/logadm -f logadm.conf -F logadm.timestamps dir2/messages -p now -a 'echo second kill -HUP `cat /var/run/*syslog*pid` >> cmd.out' >std.out4 2>std.err4
EOF
}

###########################################################################
#
#       logadm8 -- test of -z
#
###########################################################################
sub logadm8 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    system("/bin/gzip dir1/syslog.2");
    die "gzip dir1/syslog.2 didn't work\n" unless -f 'dir1/syslog.2.gz';
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    system("/bin/gzip dir1/syslog.3");
    die "gzip dir1/syslog.3 didn't work\n" unless -f 'dir1/syslog.3.gz';
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    system("/bin/gzip dir1/syslog.4");
    die "gzip dir1/syslog.4 didn't work\n" unless -f 'dir1/syslog.4.gz';
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    system("/bin/gzip dir1/syslog.5");
    die "gzip dir1/syslog.5 didn't work\n" unless -f 'dir1/syslog.5.gz';
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    system("/bin/gzip dir1/syslog.6");
    die "gzip dir1/syslog.6 didn't work\n" unless -f 'dir1/syslog.6.gz';
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    system("/bin/gzip dir1/syslog.7");
    die "gzip dir1/syslog.7 didn't work\n" unless -f 'dir1/syslog.7.gz';

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ -s dir1/syslog ] && exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2.gz ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/gzcat dir1/syslog.2.gz`" ] || exit 1
[ -f dir1/syslog.3.gz ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/gzcat dir1/syslog.3.gz`" ] || exit 1
[ -f dir1/syslog.4.gz ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/gzcat dir1/syslog.4.gz`" ] || exit 1
[ -f dir1/syslog.5.gz ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/gzcat dir1/syslog.5.gz`" ] || exit 1
[ -f dir1/syslog.6.gz ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/gzcat dir1/syslog.6.gz`" ] || exit 1
[ -f dir1/syslog.7.gz ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/gzcat dir1/syslog.7.gz`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1
[ -f dir1/syslog.8.gz ] && exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm8"
$envsetup
exec $bindir/logadm -f /dev/null dir1/syslog -z 2 -C 8 >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm9 -- test of age check
#
###########################################################################
sub logadm9 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    set_file('dir1/notes', 'initially dir1/notes');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');
    set_file('dir2/log', 'initially dir2/log');

    $now = time;
    $nowstr = gmtime($now);
    # a week minus 30 seconds ago...
    # technically not a full week, but the heuristic used by logadm
    # should think this is "close enough" to a full week
    $closetoweeksecs = $now - (60 * 60 * 24 * 7 - 30);
    $closetoweek = gmtime($closetoweeksecs);
    # a week minus six hours ago...
    $lessthanweeksecs = $now - (60 * 60 * 24 * 7 - 60 * 60 * 6);
    $lessthanweek = gmtime($lessthanweeksecs);

    set_file('logadm.conf', <<"EOF");
# now: $nowstr is $now
# $closetoweek is $closetoweeksecs
dir1/syslog -C 8 -P '$closetoweek'
dir2/log -C 4
# $lessthanweek is $lessthanweeksecs
dir1/notes -C 2 -P '$lessthanweek'
dir2/messages -C 4
EOF
    set_file('logadm.timestamps', <<"EOF");
dir2/log -P '$closetoweek'
dir2/messages -P '$lessthanweek'
EOF

    set_file('sed.out.expect', <<"EOF");
# This file holds internal data for logadm(1M).
# Do not edit.
dir1/syslog
dir2/log
dir1/notes
dir2/messages
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ -s dir1/syslog ] && exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -s dir1/notes ] || exit 1
[ "xinitially dir1/notes" = "x`/bin/cat dir1/notes`" ] || exit 1
[ -f dir1/notes.0 ] && exit 1

[ -f dir2/messages ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages`" ] || exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.2" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] || exit 1
[ "xinitially dir2/messages.3" = "x`/bin/cat dir2/messages.3`" ] || exit 1
[ -f dir2/messages.4 ] && exit 1

[ -f dir2/log ] || exit 1
[ -s dir2/log ] && exit 1
[ -f dir2/log.0 ] || exit 1
[ "xinitially dir2/log" = "x`/bin/cat dir2/log.0`" ] || exit 1
[ -f dir2/log.1 ] && exit 1

/bin/sed "s/ -P '[^']*' *//" < logadm.timestamps > sed.out
/bin/diff sed.out.expect sed.out || exit 1
/bin/sed -n "s/ -P '[^']*' */<&>/p" < logadm.conf > sed.out
[ -s sed.out ] && exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm9"
$envsetup
exec $bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm9d -- test of age check like logadm9, but age is a couple days
#
###########################################################################
sub logadm9d {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');

    $now = time;
    $nowstr = gmtime($now);
    # a day minus 30 seconds ago...
    $closetodaysecs = $now - (60 * 60 * 24 - 30);
    $closetoday = gmtime($closetodaysecs);
    # a day minus six hours ago...
    $lessthandaysecs = $now - (60 * 60 * 24 - 60 * 60 * 6);
    $lessthanday = gmtime($lessthandaysecs);

    set_file('logadm.conf', <<"EOF");
# now: $nowstr is $now
# $closetoday is $closetodaysecs
dir1/syslog -p 1d -C 8 -P '$closetoday'
# $lessthanday is $lessthandaysecs
dir2/messages -p 1d -C 4 -P '$lessthanday'
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ -s dir1/syslog ] && exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -f dir2/messages ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages`" ] || exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.2" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] || exit 1
[ "xinitially dir2/messages.3" = "x`/bin/cat dir2/messages.3`" ] || exit 1
[ -f dir2/messages.4 ] && exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm9d"
$envsetup
exec $bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm10 -- test of size-based rotation check
#
###########################################################################
sub logadm10 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslogXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');

    set_file('logadm.conf', <<"EOF");
dir1/syslog -C 8 -s 30b
dir2/messages -C 4 -s 30b
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ -s dir1/syslog ] && exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslogXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -f dir2/messages ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages`" ] || exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.2" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] || exit 1
[ "xinitially dir2/messages.3" = "x`/bin/cat dir2/messages.3`" ] || exit 1
[ -f dir2/messages.4 ] && exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm10"
$envsetup
exec $bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm11 -- test of size-based expiration check
#
###########################################################################
sub logadm11 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');

    set_file('logadm.conf', <<"EOF");
dir1/syslog -C 8 -s 30b -S 75b
dir2/messages -C 4 -s 30b -S 75b
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog`" ] || exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] && exit 1
[ -f dir1/syslog.4 ] && exit 1
[ -f dir1/syslog.5 ] && exit 1
[ -f dir1/syslog.6 ] && exit 1
[ -f dir1/syslog.7 ] && exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -f dir2/messages ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages`" ] || exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.2" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] && exit 1
[ -f dir2/messages.4 ] && exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm11"
$envsetup
exec $bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm12 -- ENOENT error path
#
###########################################################################
sub logadm12 {
    set_file('std.err.expect', <<'EOF');
logadm: Warning: logfile: No such file or directory
EOF

    set_file('checktest', <<"EOF");
[ -s std.out ] && exit 1
exec /bin/diff std.err.expect std.err
EOF

    set_file('runtest', <<"EOF");
# test "logadm12"
$envsetup
exec $bindir/logadm -f /dev/null logfile >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm13 -- ENOENT error path with -N flag
#
###########################################################################
sub logadm13 {
    set_file('checktest', <<"EOF");
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm13"
$envsetup
exec $bindir/logadm -N -f /dev/null logfile >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm14 -- test of -n and -v flags
#
###########################################################################
sub logadm14 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');
    mkdir 'dir2', 0777 or die "mkdir dir2: $!\n";
    set_file('dir2/messages', 'initially dir2/messages');
    set_file('dir2/messages.0', 'initially dir2/messages.0');
    set_file('dir2/messages.1', 'initially dir2/messages.1');
    set_file('dir2/messages.2', 'initially dir2/messages.2');
    set_file('dir2/messages.3', 'initially dir2/messages.3');

    set_file('logadm.conf', <<'EOF');
#
# logadm.conf
#
# Default settings for system log file management.
# The -w option to logadm(1M) is the preferred way to write to this file,
# but if you do edit it by hand, use "logadm -V" to check it for errors.
# but if you do edit it by hand, use "logadm -V" to check it for errors.
#
# The format of lines in this file is:
#       <logname> <options>
# For each logname listed here, the default options to logadm
# are given.  Options given on the logadm command line override
# the defaults contained in this file.
#
# logadm typically runs early every morning via an entry in
# root's crontab (see crontab(1)).
#
dir1/syslog -C 8 -a 'echo kill -HUP `cat /var/run/*syslog*pid` >> cmd.out'
dir2/messages -C 4 -a 'echo kill -HUP `cat /var/run/*syslog*pid` >> cmd.out'
#
# The entry below is used by turnacct(1M)
#
/var/adm/pacct -C 0 -a '/usr/lib/acct/accton pacct' -g adm -m 664 -o adm -p never
EOF

    $gid = $);
    $gid =~ s/ .*//;
    set_file('grep.out.expect', <<'EOF'.<<"EOF".<<'EOF'.<<"EOF".<<'EOF');
# loading logadm.conf
# processing logname: dir1/syslog
#     using default rotate rules: -s1b -p1w
#     using default template: $file.$n
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.7 dir1/syslog.8 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.6 dir1/syslog.7 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.5 dir1/syslog.6 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.4 dir1/syslog.5 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.3 dir1/syslog.4 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.2 dir1/syslog.3 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.1 dir1/syslog.2 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog.0 dir1/syslog.1 # rotate log file
mkdir -p dir1 # verify directory exists
mv -f dir1/syslog dir1/syslog.0 # rotate log file
touch dir1/syslog
EOF
chown $>:$gid dir1/syslog
EOF
chmod 664 dir1/syslog
# processing logname: dir2/messages
#     using default rotate rules: -s1b -p1w
#     using default template: $file.$n
mkdir -p dir2 # verify directory exists
mv -f dir2/messages.3 dir2/messages.4 # rotate log file
mkdir -p dir2 # verify directory exists
mv -f dir2/messages.2 dir2/messages.3 # rotate log file
mkdir -p dir2 # verify directory exists
mv -f dir2/messages.1 dir2/messages.2 # rotate log file
mkdir -p dir2 # verify directory exists
mv -f dir2/messages.0 dir2/messages.1 # rotate log file
mkdir -p dir2 # verify directory exists
mv -f dir2/messages dir2/messages.0 # rotate log file
touch dir2/messages
EOF
chown $>:$gid dir2/messages
EOF
chmod 664 dir2/messages
# processing logname: /var/adm/pacct
#     using default template: $file.$n
sh -c echo kill -HUP `cat /var/run/*syslog*pid` >> cmd.out # -a cmd
# logadm.conf and logadm.timestamps unchanged
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -f std.out ] || exit 1
[ -f dir1/syslog ] || exit 1
[ "xinitially dir1/syslog" = "x`/bin/cat dir1/syslog`" ] || exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.7" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

[ -f dir2/messages ] || exit 1
[ "xinitially dir2/messages" = "x`/bin/cat dir2/messages`" ] || exit 1
[ -f dir2/messages.0 ] || exit 1
[ "xinitially dir2/messages.0" = "x`/bin/cat dir2/messages.0`" ] || exit 1
[ -f dir2/messages.1 ] || exit 1
[ "xinitially dir2/messages.1" = "x`/bin/cat dir2/messages.1`" ] || exit 1
[ -f dir2/messages.2 ] || exit 1
[ "xinitially dir2/messages.2" = "x`/bin/cat dir2/messages.2`" ] || exit 1
[ -f dir2/messages.3 ] || exit 1
[ "xinitially dir2/messages.3" = "x`/bin/cat dir2/messages.3`" ] || exit 1
[ -f dir2/messages.4 ] && exit 1
/bin/grep -v 'recording rotation date' std.out > grep.out
exec /bin/diff grep.out.expect grep.out
EOF

        set_file('runtest', <<"EOF");
# test "logadm14"
$envsetup
exec $bindir/logadm -nv -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm15 -- test of -T
#
###########################################################################
sub logadm15 {
    set_file('logfile', '');
    set_file('logfile.0', 'initially logfile.0');
    set_file('logfile.1', 'initially logfile.1');
    set_file('logfile.2', 'initially logfile.2');
    set_file('logfile.3', 'initially logfile.3');
    set_file('logfile.4', 'initially logfile.4');
    set_file('logfile.5', 'initially logfile.5');
    set_file('logfile.6', 'initially logfile.6');
    set_file('logfile.7', 'initially logfile.7');
    set_file('logfile.8', 'initially logfile.8');
    set_file('logfile.9', 'initially logfile.9');

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f logfile ] || exit 1
[ "x" = "x`/bin/cat logfile`" ] || exit 1
[ -f logfile.0 ] || exit 1
[ "xinitially logfile.0" = "x`/bin/cat logfile.0`" ] || exit 1
[ -f logfile.1 ] || exit 1
[ "xinitially logfile.1" = "x`/bin/cat logfile.1`" ] || exit 1
[ -f logfile.2 ] || exit 1
[ "xinitially logfile.2" = "x`/bin/cat logfile.2`" ] || exit 1
[ -f logfile.3 ] && exit 1
[ -f logfile.4 ] || exit 1
[ "xinitially logfile.4" = "x`/bin/cat logfile.4`" ] || exit 1
[ -f logfile.5 ] && exit 1
[ -f logfile.6 ] || exit 1
[ "xinitially logfile.6" = "x`/bin/cat logfile.6`" ] || exit 1
[ -f logfile.7 ] && exit 1
[ -f logfile.8 ] || exit 1
[ "xinitially logfile.8" = "x`/bin/cat logfile.8`" ] || exit 1
[ -f logfile.9 ] && exit 1
[ -f logfile.10 ] && exit 1
exit 0
EOF

    set_file('runtest', <<"EOF");
# test "logadm15"
$envsetup
exec $bindir/logadm -f /dev/null logfile -C1 -T '*.[13579]'>std.out 2>std.err
EOF
}

###########################################################################
#
#   logadm16 -- test of -h
#
###########################################################################
sub logadm16 {
    set_file('std.err.expect', <<'EOF');
Usage: logadm [options]
       (processes all entries in /etc/logadm.conf or conffile given by -f)
   or: logadm [options] logname...
       (processes the given lognames)

General options:
        -e mailaddr     mail errors to given address
        -F timestamps   use timestamps instead of /var/logadm/timestamps
        -f conffile     use conffile instead of /etc/logadm.conf
        -h              display help
        -N              not an error if log file nonexistent
        -n              show actions, don't perform them
        -r              remove logname entry from conffile
        -V              ensure conffile entries exist, correct
        -v              print info about actions happening
        -w entryname    write entry to config file

Options which control when a logfile is rotated:
(default is: -s1b -p1w if no -s or -p)
        -p period       only rotate if period passed since last rotate
        -P timestamp    used to store rotation date in conffile
        -s size         only rotate if given size or greater

Options which control how a logfile is rotated:
(default is: -t '$file.$n', owner/group/mode taken from log file)
        -a cmd          execute cmd after taking actions
        -b cmd          execute cmd before taking actions
        -c              copy & truncate logfile, don't rename
        -g group        new empty log file group
        -l              rotate log file with local time rather than UTC
        -m mode         new empty log file mode
        -M cmd          execute cmd to rotate the log file
        -o owner        new empty log file owner
        -R cmd          run cmd on file after rotate
        -t template     template for naming old logs
        -z count        gzip old logs except most recent count

Options which control the expiration of old logfiles:
(default is: -C10 if no -A, -C, or -S)
        -A age          expire logs older than age
        -C count        expire old logs until count remain
        -E cmd          run cmd on file to expire
        -S size         expire until space used is below size
        -T pattern      pattern for finding old logs
EOF

    set_file('checktest', <<'EOF');
[ -s std.out ] && exit 1
exec /bin/diff std.err.expect std.err
EOF

    set_file('runtest', <<"EOF");
# test "logadm16"
$envsetup
exec $bindir/logadm -h >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm17 -- test that mkdir -p happens as necessary
#
###########################################################################
sub logadm17 {
    set_file('logfile', 'initially logfile');

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/dir2/logfile ] || exit 1
[ -f logfile ] || exit 1
[ "xinitially logfile" = "x`/bin/cat dir1/dir2/logfile`" ] || exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm17"
$envsetup
exec $bindir/logadm -f /dev/null -t 'dir1/dir2/\$basename' logfile -p now >std.out 2>std.err
EOF
}

###########################################################################
#
#       logadm18 -- test of -M option
#
###########################################################################
sub logadm18 {
    mkdir 'dir1', 0777 or die "mkdir dir1: $!\n";
    set_file('dir1/syslog', 'initially dir1/syslog');
    set_file('dir1/syslog.0', 'initially dir1/syslog.0');
    set_file('dir1/syslog.1', 'initially dir1/syslog.1');
    set_file('dir1/syslog.2', 'initially dir1/syslog.2');
    set_file('dir1/syslog.3', 'initially dir1/syslog.3');
    set_file('dir1/syslog.4', 'initially dir1/syslog.4');
    set_file('dir1/syslog.5', 'initially dir1/syslog.5');
    set_file('dir1/syslog.6', 'initially dir1/syslog.6');
    set_file('dir1/syslog.7', 'initially dir1/syslog.7');

    set_file('logadm.conf', <<"EOF");
dir1/syslog -C 8 -s 1b -M '/bin/tr [a-z] [A-Z] < \$file > \$nfile; /bin/rm -f \$file'
EOF

    set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -f dir1/syslog ] || exit 1
[ -s dir1/syslog ] && exit 1
[ -f dir1/syslog.0 ] || exit 1
[ "xINITIALLY DIR1/SYSLOG" = "x`/bin/cat dir1/syslog.0`" ] || exit 1
[ -f dir1/syslog.1 ] || exit 1
[ "xinitially dir1/syslog.0" = "x`/bin/cat dir1/syslog.1`" ] || exit 1
[ -f dir1/syslog.2 ] || exit 1
[ "xinitially dir1/syslog.1" = "x`/bin/cat dir1/syslog.2`" ] || exit 1
[ -f dir1/syslog.3 ] || exit 1
[ "xinitially dir1/syslog.2" = "x`/bin/cat dir1/syslog.3`" ] || exit 1
[ -f dir1/syslog.4 ] || exit 1
[ "xinitially dir1/syslog.3" = "x`/bin/cat dir1/syslog.4`" ] || exit 1
[ -f dir1/syslog.5 ] || exit 1
[ "xinitially dir1/syslog.4" = "x`/bin/cat dir1/syslog.5`" ] || exit 1
[ -f dir1/syslog.6 ] || exit 1
[ "xinitially dir1/syslog.5" = "x`/bin/cat dir1/syslog.6`" ] || exit 1
[ -f dir1/syslog.7 ] || exit 1
[ "xinitially dir1/syslog.6" = "x`/bin/cat dir1/syslog.7`" ] || exit 1
[ -f dir1/syslog.8 ] && exit 1

exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm18"
$envsetup
exec $bindir/logadm -f logadm.conf -F logadm.timestamps >std.out 2>std.err
EOF
}

#############################################################################
#
#         logadm19 -- test of  -l
#
#############################################################################
sub logadm19 {
        set_file('logfile', 'initially logfile');

        set_file('checktest', <<'EOF');
[ -s std.err ] && { cat std.err; exit 1; }
[ -s std.out ] && exit 1
[ -s logfile ] && exit 1
TZ= export TZ
d=`/bin/date +\%d\%H\%M`
[ -f logfile.$d ] || exit 1
[ "xinitially logfile" = "x`/bin/cat logfile.$d`" ] || exit 1
exit 0
EOF

        set_file('runtest', <<"EOF");
# test "logadm19"
$envsetup
exec $bindir/logadm -f /dev/null -l -p now logfile -t '\$file.\%d\%H\%M' >std.out 2>std.err
EOF
}

#############################################################################
#
#         logadm20 -- test of unquotables/error handling
#
#############################################################################
sub logadm20 {
    set_file('logadm.conf', <<'EOF');
# non-trivial entry
/var/log/syslog -C 8 -a 'kill -HUP `cat /var/run/*syslog*pid`'
EOF

    set_file('std.err.expect', <<'EOF');
logadm: Error: Can't protect quotes in </bin/echo "She can't take anymore, Cap'n!">
logadm: Error: unsafe to update configuration file or timestamps
logadm: Error: bailing out due to command line errors
Use "logadm -h" for help.
exit=1
EOF

        set_file('checktest', <<'EOF');
[ -s std.err ] || exit 1
[ -s std.out ] && exit 1
[ -f logadm.conf????? ] && exit 1
[ -f logadm.timestamps????? ] && exit 1
exec /bin/diff std.err.expect std.err
EOF

        set_file('runtest', <<"EOF");
# test "logadm20"
$envsetup
$bindir/logadm -f logadm.conf -F logadm.timestamps -w /a/b/c -p 1w -l -b "/bin/echo \\"She can't take anymore, Cap'n!\\"" >std.out 2>std.err
echo exit=\$? >>std.err
EOF
}

#############################################################################
#
#         logadm21 -- test of busted configuration file
#
#############################################################################
sub logadm21 {
    set_file('logadm.conf', <<'EOF');
poop
EOF
    set_file('checktest', <<'EOF');
[ -s std.err ] || exit 1
grep Warning std.err > /dev/null
EOF

        set_file('runtest', <<"EOF");
# test "logadm21"
$envsetup
$bindir/logadm -f logadm.conf 2>std.err
exit 0
EOF
}