mirror of
https://github.com/MariaDB/server.git
synced 2025-07-13 06:48:13 +02:00
0b7b5cc1b3
Added option 'aria-pagecache-segments', default 1.
For values > 1, this split the aria-pagecache-buffer into the given
number of segments, each independent from each other. Having multiple
pagecaches improve performance when multiple connections runs queries
concurrently using different tables.
Each pagecache will use aria-pageache-buffer/segments amount of
memory, however at least 128K.
Each opened table has its index and data file use the segments in a
a round-robin fashion.
Internal changes:
- All programs allocating the maria pagecache themselves should now
call multi_init_pagecache() instead of init_pagecache().
- pagecache statistics is now stored in 'pagecache_stats' instead of
maria_pagecache. One must call multi_update_pagecache_stats() to
update the statistics.
- Added into PAGECACHE_FILE a pointer to files pagecache. This was
done to ensure that index and data file are using the same
pagecache and simplified the checkpoint code.
I kept pagecache in TABLE_SHARE to minimize the changes.
- really_execute_checkpoint() was update to handle a dynamic number of
pagecaches.
- pagecache_collect_changed_blocks_with_lsn() was slight changed to
allow it to be called for each pagecache.
- undefined not used functions maria_assign_pagecache() and
maria_change_pagecache()
- ma_pagecaches.c is totally rewritten. It now contains all
multi_pagecache functions.
Errors found be QA that are fixed:
MDEV-36872 UBSAN errors in ma_checkpoint.c
MDEV-36874 Behavior upon too small aria_pagecache_buffer_size in case of
multiple segments is not very user-friendly
MDEV-36914 ma_checkpoint.c(285,9): conversion from '__int64' to 'uint'
treated as an error
MDEV-36912 sys_vars.sysvars_server_embedded and
sys_vars.sysvars_server_notembedded fail on x86
769 lines
24 KiB
Perl
Executable file
769 lines
24 KiB
Perl
Executable file
#!/usr/bin/env perl
|
|
#
|
|
# Run various unit tests.
|
|
#
|
|
|
|
use Getopt::Long;
|
|
use File::Basename;
|
|
|
|
$|= 1;
|
|
$^W = 1; # warnings, because env cannot parse 'perl -w'
|
|
$VER= "1.5";
|
|
|
|
$opt_version= 0;
|
|
$opt_help= 0;
|
|
$opt_verbose= 0;
|
|
$opt_abort_on_error= 0;
|
|
$opt_valgrind= "valgrind --alignment=8 --leak-check=yes";
|
|
$opt_silent= "-s";
|
|
$opt_number_of_tests= 0;
|
|
$opt_run_tests= undef();
|
|
|
|
my $maria_path; # path to "storage/maria"
|
|
my $maria_exe_path; # path to executables (ma_test1, aria_chk etc)
|
|
my $my_progname= $0;
|
|
$my_progname=~ s/.*[\/]//;
|
|
my $runtime_error= 0; # Return 1 if error(s) occur during run
|
|
my $NEW_TEST= 0; # Test group separator in an array of tests
|
|
my $test_begin= 0;
|
|
my $test_end= 0;
|
|
my $test_counter= 0;
|
|
my $using_internal_tmpdir= 0;
|
|
my $full_tmpdir;
|
|
my $tmpdir="tmp";
|
|
my $exec_dir="TMP-ma_test_all"; # Run test in this directory
|
|
run_tests();
|
|
|
|
####
|
|
#### Initialise variables, clean temporary files and run the tests
|
|
####
|
|
|
|
sub run_tests
|
|
{
|
|
my $nr_tests= 0;
|
|
my $flag_exit= 0;
|
|
|
|
if (!GetOptions("help" => \$opt_help,
|
|
"version" => \$opt_version,
|
|
"verbose" => \$opt_verbose,
|
|
"abort-on-error" => \$opt_abort_on_error,
|
|
"valgrind=s" => \$opt_valgrind,
|
|
"silent=s" => \$opt_silent,
|
|
"tmpdir=s" => \$full_tmpdir,
|
|
"number-of-tests" => \$opt_number_of_tests,
|
|
"run-tests=s" => \$opt_run_tests,
|
|
"start-from=s" => \$opt_run_tests))
|
|
{
|
|
$flag_exit= 1;
|
|
}
|
|
if ($opt_version)
|
|
{
|
|
print "$my_progname version $VER\n";
|
|
exit(0);
|
|
}
|
|
|
|
if (! -d $exec_dir)
|
|
{
|
|
die if (!mkdir("$exec_dir"));
|
|
}
|
|
chdir($exec_dir);
|
|
|
|
$maria_path= "../" . dirname($0) . "/..";
|
|
|
|
my $suffix= ( $^O =~ /win/i && $^O !~ /darwin/i ) ? ".exe" : "";
|
|
$maria_exe_path= "$maria_path/release";
|
|
# we use -f, sometimes -x is unexpectedly false in Cygwin
|
|
if ( ! -f "$maria_exe_path/ma_test1$suffix" )
|
|
{
|
|
$maria_exe_path= "$maria_path/relwithdebinfo";
|
|
if ( ! -f "$maria_exe_path/ma_test1$suffix" )
|
|
{
|
|
$maria_exe_path= "$maria_path/debug";
|
|
if ( ! -f "$maria_exe_path/ma_test1$suffix" )
|
|
{
|
|
$maria_exe_path= $maria_path;
|
|
if ( ! -f "$maria_exe_path/ma_test1$suffix" )
|
|
{
|
|
die("Cannot find ma_test1 executable in $maria_path\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
usage() if ($opt_help || $flag_exit);
|
|
|
|
if (defined($full_tmpdir))
|
|
{
|
|
$tmpdir= $full_tmpdir;
|
|
}
|
|
else
|
|
{
|
|
$full_tmpdir= $tmpdir;
|
|
$using_internal_tmpdir= 1;
|
|
if (! -d "$full_tmpdir")
|
|
{
|
|
die if (!mkdir("$full_tmpdir"));
|
|
}
|
|
}
|
|
|
|
#
|
|
# IMPORTANT: If you modify this file, please read this:
|
|
#
|
|
# Count total number of tests. Make sure that the functions return
|
|
# number of unit tests correctly, e.g. calls to ok(). The last argument
|
|
# for each function is a flag counter and will return the number of
|
|
# unit tests in each. Please see comments on function ok() at the end.
|
|
#
|
|
# If you modify any functions or add any new ones, please make sure the
|
|
# unit tests are appropriately detected here. A wrong count will
|
|
# make the unit test fail during 'make test'. $nr_tests must be right.
|
|
#
|
|
|
|
$nr_tests+= run_check_tests(0, 0, 0, 0, 1) * 5; #
|
|
$nr_tests+= run_repair_tests(0, 0, 0, 0, 1) * 5; # called 4 times
|
|
$nr_tests+= run_pack_tests(0, 0, 0, 0, 1) * 5; #
|
|
$nr_tests+= run_tests_on_warnings_and_errors(0, 0, 0, 1);
|
|
$nr_tests+= run_ma_test_recovery(0, 1);
|
|
$nr_tests+= run_tests_on_clrs(0, 0, 1);
|
|
|
|
if ($opt_number_of_tests)
|
|
{
|
|
print "Total number of tests is $nr_tests\n";
|
|
exit(0);
|
|
}
|
|
|
|
if (defined($opt_run_tests))
|
|
{
|
|
if ($opt_run_tests =~ m/^(\d+)$/ ||
|
|
$opt_run_tests =~ m/^(\d+)\.+$/)
|
|
{
|
|
$test_begin= $1;
|
|
}
|
|
elsif ($opt_run_tests =~ m/^(\d+)\.+(\d+)$/)
|
|
{
|
|
$test_begin= $1;
|
|
$test_end= $2;
|
|
}
|
|
else
|
|
{
|
|
print "Wrong syntax for option --run-tests=$opt_run_tests\n";
|
|
print "Please use --run-tests=<begin>..<end>\nwhere 'begin' is the ";
|
|
print "first test to be run and 'end' is the last.\n";
|
|
exit(1);
|
|
}
|
|
if ($test_end > $nr_tests)
|
|
{
|
|
print "Test range ($test_begin..$test_end) out of range. ";
|
|
print "There are only $nr_tests in the test suite.\n";
|
|
exit(1);
|
|
}
|
|
$test_begin++ if (!$test_begin); # Handle zero, if user gave that
|
|
if ($test_end && $test_begin > $test_end)
|
|
{
|
|
print "Bad test range ($test_begin..$test_end)\n";
|
|
exit(1);
|
|
}
|
|
# Now adjust number of tests
|
|
$nr_tests= ($test_end ? $test_end : $nr_tests) - $test_begin + 1;
|
|
}
|
|
|
|
#
|
|
# clean-up
|
|
#
|
|
|
|
unlink_all_possible_tmp_files();
|
|
|
|
#
|
|
# Run tests
|
|
#
|
|
|
|
if (!$opt_verbose)
|
|
{
|
|
print "1..$nr_tests\n";
|
|
}
|
|
else
|
|
{
|
|
print "Total tests: $nr_tests\n";
|
|
}
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "Running tests with dynamic row format\n"
|
|
}
|
|
run_check_tests($suffix, $opt_silent, "", $opt_verbose, 0);
|
|
run_repair_tests($suffix, $opt_silent, "", $opt_verbose, 0);
|
|
run_pack_tests($suffix, $opt_silent, "", $opt_verbose, 0);
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "\nRunning tests with static row format\n";
|
|
}
|
|
run_check_tests($suffix, $opt_silent, "-S", $opt_verbose, 0);
|
|
run_repair_tests($suffix, $opt_silent, "-S", $opt_verbose, 0);
|
|
run_pack_tests($suffix, $opt_silent, "-S", $opt_verbose, 0);
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "\nRunning tests with block row format\n";
|
|
}
|
|
run_check_tests($suffix, $opt_silent, "-M", $opt_verbose, 0);
|
|
run_repair_tests($suffix, $opt_silent, "-M", $opt_verbose, 0);
|
|
run_pack_tests($suffix, $opt_silent, "-M", $opt_verbose, 0);
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "\nRunning tests with block row format and transactions\n";
|
|
}
|
|
run_check_tests($suffix, $opt_silent, "-M -T", $opt_verbose, 0);
|
|
run_repair_tests($suffix, $opt_silent, "-M -T", $opt_verbose, 0);
|
|
run_pack_tests($suffix, $opt_silent, "-M -T", $opt_verbose, 0);
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "\nRunning tests with block row format, transactions and versioning\n";
|
|
}
|
|
run_check_tests($suffix, $opt_silent, "-M -T -C", $opt_verbose, 0);
|
|
run_repair_tests($suffix, $opt_silent, "-M -T -C", $opt_verbose, 0);
|
|
run_pack_tests($suffix, $opt_silent, "-M -T -C", $opt_verbose, 0);
|
|
|
|
|
|
if ($opt_verbose)
|
|
{
|
|
print "\nRunning tests with warnings and recovery\n";
|
|
}
|
|
run_tests_on_warnings_and_errors($suffix, $opt_silent, $opt_verbose, 0);
|
|
run_ma_test_recovery($opt_verbose, 0);
|
|
run_tests_on_clrs($suffix, $opt_verbose, 0);
|
|
|
|
unlink_all_possible_tmp_files();
|
|
if ($using_internal_tmpdir)
|
|
{
|
|
rmdir($tmpdir);
|
|
}
|
|
rmdir($exec_dir);
|
|
chdir("..");
|
|
rmdir($exec_dir);
|
|
exit($runtime_error);
|
|
}
|
|
|
|
####
|
|
#### regular tests
|
|
####
|
|
|
|
sub run_check_tests
|
|
{
|
|
my ($suffix, $silent, $row_type, $verbose, $count)= @_;
|
|
my ($i, $nr_tests);
|
|
my @ma_test1_opt= ( ["","-se"],
|
|
["-N","-se"],
|
|
["-P --checksum","-se"],
|
|
["-P -N","-se"],
|
|
["-B -N -R2","-sm"],
|
|
["-a -k 480 --unique","-sm"],
|
|
["-a -N -R1 ","-sm"],
|
|
["-p","-sm"],
|
|
["-p -N --unique","-sm"],
|
|
["-p -N --key_length=127 --checksum","-sm"],
|
|
["-p -N --key_length=128","-sm"],
|
|
["-p --key_length=480","-sm"],
|
|
["-a -B","-sm"],
|
|
["-a -B --key_length=64 --unique","-sm"],
|
|
["-a -B -k 480 --checksum","-sm"],
|
|
["-a -B -k 480 -N --unique --checksum","-sm"],
|
|
["-a -m","-sm"],
|
|
["-a -m -P --unique --checksum","-sm"],
|
|
["-a -m -P --key_length=480 --key_cache","-sm"],
|
|
["-m -p","-sm"],
|
|
["-w --unique","-sm"],
|
|
["-a -w --key_length=64 --checksum","-sm"],
|
|
["-a -w -N --key_length=480","-sm"],
|
|
["-a -w --key_length=480 --checksum","-sm"],
|
|
["-a -b -N","-sm"],
|
|
["-a -b --key_length=480","-sm"],
|
|
["-p -B --key_length=480","-sm"],
|
|
["--checksum --unique","-se"],
|
|
["--unique","-se"],
|
|
["--rows-no-data", "-s"],
|
|
["--key_multiple -N -S","-sm"],
|
|
["--key_multiple -a -p --key_length=480","-sm"],
|
|
["--key_multiple -a -B --key_length=480","-sm"],
|
|
["--key_multiple -P -S","-sm"] );
|
|
my @ma_test2_opt= ( ["-L -K -W -P","-sm"],
|
|
["-L -K -W -P -A -p4","-sm"],
|
|
["-L -K -W -P -b32768", "-sm"],
|
|
["-L -K -W -P -M -T -c -b32768 -t4 -m300", "-sm"],
|
|
["-L -K -P -R3 -m50 -b1000000", "-sm"],
|
|
["-L -B","-sm"],
|
|
["-D -B -c","-sm"],
|
|
["-m10000 -e4096 -K","-sm"],
|
|
["-m10000 -e8192 -K","-sm"],
|
|
["-m10000 -e16384 -E16384 -K -L","-sm"],
|
|
["-L -K -W -P -b32768", "-se"],
|
|
["-c -b65000","-se"] );
|
|
my @ma_rt_test_opt= ( ); # (["--checksum", "-se"] );
|
|
|
|
|
|
if ($count)
|
|
{
|
|
$nr_tests= 2; # Number of tests outside loops
|
|
for ($i= 0; defined($ma_test1_opt[$i]); $i++) { $nr_tests+=2; }
|
|
for ($i= 0; defined($ma_test2_opt[$i]); $i++) { $nr_tests+=2; }
|
|
for ($i= 0; defined($ma_rt_test_opt[$i]); $i++) { $nr_tests+=2; }
|
|
return $nr_tests;
|
|
}
|
|
|
|
for ($i= 0; defined($ma_test1_opt[$i]); $i++)
|
|
{
|
|
unlink_log_files();
|
|
ok("$maria_exe_path/ma_test1$suffix $silent -h$tmpdir $ma_test1_opt[$i][0] $row_type",
|
|
$verbose, $i + 1);
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir $ma_test1_opt[$i][1] $tmpdir/test1",
|
|
$verbose, $i + 1);
|
|
}
|
|
#
|
|
# These tests are outside the loops. Make sure to include them in
|
|
# nr_tests manually
|
|
#
|
|
ok("$maria_exe_path/aria_pack$suffix --force -s $tmpdir/test1", $verbose, 0);
|
|
ok("$maria_exe_path/aria_chk$suffix -ess $tmpdir/test1", $verbose, 0);
|
|
|
|
for ($i= 0; defined($ma_test2_opt[$i]); $i++)
|
|
{
|
|
unlink_log_files();
|
|
ok("$maria_exe_path/ma_test2$suffix $silent -h$tmpdir $ma_test2_opt[$i][0] $row_type",
|
|
$verbose, $i + 1);
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir $ma_test2_opt[$i][1] $tmpdir/test2",
|
|
$verbose, $i + 1);
|
|
}
|
|
|
|
for ($i= 0; defined($ma_rt_test_opt[$i]); $i++)
|
|
{
|
|
unlink_log_files();
|
|
ok("$maria_exe_path/ma_rt_test$suffix $silent -h$tmpdir $ma_rt_test_opt[$i][0] $row_type",
|
|
$verbose, $i + 1);
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir $ma_rt_test_opt[$i][1] $tmpdir/rt_test",
|
|
$verbose, $i + 1);
|
|
}
|
|
|
|
unlink_log_files();
|
|
|
|
return 0;
|
|
}
|
|
|
|
####
|
|
#### repair tests
|
|
####
|
|
|
|
sub run_repair_tests()
|
|
{
|
|
my ($suffix, $silent, $row_type, $verbose, $count)= @_;
|
|
my ($i);
|
|
|
|
my @t= ($NEW_TEST,
|
|
"$maria_exe_path/ma_test1$suffix $silent --checksum $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix --silent -re --transaction-log test1",
|
|
"$maria_exe_path/aria_chk$suffix -rs test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqs test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -rs --correct-checksum test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqs --correct-checksum test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -ros --correct-checksum test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqos --correct-checksum test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -sz test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/ma_test2$suffix $silent -c -d1 $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -s --parallel-recover test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/aria_chk$suffix -s --parallel-recover --quick test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/ma_test2$suffix $silent -c $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/aria_chk$suffix -sr test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/ma_test2$suffix $silent -c -t4 -b32768 $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -s --zerofill test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1"
|
|
);
|
|
|
|
return &count_tests(\@t) if ($count);
|
|
&run_test_bunch(\@t, $verbose, 0);
|
|
return 0;
|
|
}
|
|
|
|
####
|
|
#### pack tests
|
|
####
|
|
|
|
sub run_pack_tests()
|
|
{
|
|
my ($suffix, $silent, $row_type, $verbose, $count)= @_;
|
|
my ($i);
|
|
|
|
my @t= ($NEW_TEST,
|
|
"$maria_exe_path/ma_test1$suffix $silent --checksum $row_type",
|
|
"$maria_exe_path/aria_pack$suffix --force -s test1",
|
|
"$maria_exe_path/aria_chk$suffix -ess test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqs test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
"$maria_exe_path/aria_chk$suffix -rs test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
"$maria_exe_path/aria_chk$suffix -rus test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test1$suffix $silent --checksum $row_type",
|
|
"$maria_exe_path/aria_pack$suffix --force -s test1",
|
|
"$maria_exe_path/aria_chk$suffix -rus --safe-recover test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test1$suffix $silent --checksum -S $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
"$maria_exe_path/aria_chk$suffix -ros test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqs test1",
|
|
"$maria_exe_path/aria_chk$suffix -se test1",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/aria_pack$suffix --force -s test1",
|
|
"$maria_exe_path/aria_chk$suffix -rqs test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
"$maria_exe_path/aria_chk$suffix -rus test1",
|
|
"$maria_exe_path/aria_chk$suffix -es test1",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test2$suffix $silent -c -d1 $row_type",
|
|
"$maria_exe_path/aria_chk$suffix -s --parallel-recover test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/aria_chk$suffix -s --unpack --parallel-recover test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
"$maria_exe_path/aria_pack$suffix --force -s test1",
|
|
"$maria_exe_path/aria_chk$suffix -s --unpack --parallel-recover test2",
|
|
"$maria_exe_path/aria_chk$suffix -se test2",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test1$suffix $silent -c $row_type",
|
|
"cp test1.MAD test2.MAD",
|
|
"cp test1.MAI test2.MAI",
|
|
"$maria_exe_path/aria_pack$suffix --force -s --join=test3 test1 test2",
|
|
);
|
|
|
|
return (&count_tests(\@t) + 3) if ($count);
|
|
&run_test_bunch(\@t, $verbose, 0);
|
|
|
|
ok("$maria_exe_path/aria_chk -s test3", $verbose, 0, 1);
|
|
@t= ("$maria_exe_path/aria_chk -s --safe-recover test3",
|
|
"$maria_exe_path/aria_chk -s test3");
|
|
&run_test_bunch(\@t, $verbose, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
####
|
|
#### Tests that gives warnings or errors
|
|
####
|
|
|
|
sub run_tests_on_warnings_and_errors
|
|
{
|
|
my ($suffix, $silent, $verbose, $count)= @_;
|
|
my ($com);
|
|
|
|
return 9 if ($count); # Number of tests in this function, e.g. calls to ok()
|
|
|
|
ok("$maria_exe_path/ma_test2$suffix -h$tmpdir $silent -L -K -W -P -S -R1 -m500",
|
|
$verbose, 0);
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir -sm $tmpdir/test2", $verbose, 0);
|
|
# ma_test2$suffix $silent -L -K -R1 -m2000 ; Should give error 135\n
|
|
# In the following a failure is a success and success is a failure
|
|
$com= "$maria_exe_path/ma_test2$suffix -h$tmpdir $silent -L -K -R1 -m2000 ";
|
|
$com.= ">ma_test2_message.txt 2>&1";
|
|
ok($com, $verbose, 0, 1);
|
|
ok("cat ma_test2_message.txt", $verbose, 0);
|
|
ok("grep \"Error: 135\" ma_test2_message.txt > /dev/null", $verbose, 0);
|
|
# maria_exe_path/aria_chk$suffix -h$tmpdir -sm $tmpdir/test2 will warn that
|
|
# Datafile is almost full
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir -sm $tmpdir/test2 >ma_test2_message.txt 2>&1",
|
|
$verbose, 0, 1);
|
|
ok("cat ma_test2_message.txt", $verbose, 0);
|
|
ok("grep \"warning: Datafile is almost full\" ma_test2_message.txt>/dev/null",
|
|
$verbose, 0);
|
|
unlink <ma_test2_message.txt>;
|
|
ok("$maria_exe_path/aria_chk$suffix -h$tmpdir -ssm $tmpdir/test2", $verbose, 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
####
|
|
#### Test that removing tables and applying the log leads to identical tables
|
|
####
|
|
|
|
sub run_ma_test_recovery
|
|
{
|
|
my ($verbose, $count)= @_;
|
|
|
|
return 1 if ($count); # Number of tests in this function
|
|
ok("$maria_path/unittest/ma_test_recovery.pl", $verbose, 0);
|
|
return 0;
|
|
}
|
|
|
|
####
|
|
#### Tests on CLR's
|
|
####
|
|
|
|
sub run_tests_on_clrs
|
|
{
|
|
my ($suffix, $verbose, $count)= @_;
|
|
my ($i);
|
|
|
|
my @t= ($NEW_TEST,
|
|
"$maria_exe_path/ma_test2$suffix -h$tmpdir -s -L -K -W -P -M -T -c -b -t2 -A1",
|
|
"cp $tmpdir/aria_log_control $tmpdir/aria_log_control.backup",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -s -e $tmpdir/test2",
|
|
"mv $tmpdir/aria_log_control.backup $tmpdir/aria_log_control",
|
|
"rm $tmpdir/test2.MA?",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -s -e $tmpdir/test2",
|
|
"rm $tmpdir/test2.MA?",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test2$suffix -h$tmpdir -s -L -K -W -P -M -T -c -b -t2 -A1 -p4",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir ",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -s -e $tmpdir/test2",
|
|
"rm $tmpdir/test2.MA?",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -e -s $tmpdir/test2",
|
|
"rm $tmpdir/test2.MA?",
|
|
$NEW_TEST,
|
|
"$maria_exe_path/ma_test2$suffix -h$tmpdir -s -L -K -W -P -M -T -c -b32768 -t4 -A1",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -es $tmpdir/test2",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir ",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -es $tmpdir/test2",
|
|
"rm $tmpdir/test2.MA?",
|
|
"$maria_exe_path/aria_read_log$suffix -a -s -h$tmpdir",
|
|
"$maria_exe_path/aria_chk$suffix -h$tmpdir -es $tmpdir/test2",
|
|
"rm $tmpdir/test2.MA?"
|
|
);
|
|
|
|
return &count_tests(\@t) if ($count);
|
|
&run_test_bunch(\@t, $verbose, 1);
|
|
return 0;
|
|
}
|
|
|
|
#
|
|
# Print "ok" on success and "not ok" on error
|
|
#
|
|
# Note: Every time this function is called it will be counted
|
|
# as a unit test.
|
|
#
|
|
# Args: $com: The actual command run. Will be printed on a failure
|
|
# $verbose: Be more verbose.
|
|
# $iteration: Number of iterations in a loop when the error
|
|
# occurred. If not in loop, this should be blank
|
|
# (e.g. send zero).
|
|
# $expected_error: Optional; put here expected error code. Test
|
|
# will pass with this result only.
|
|
#
|
|
# Return value: Will return 1 on success and 0 on an error
|
|
#
|
|
|
|
sub ok
|
|
{
|
|
my ($com, $verbose, $iteration, $expected_error)= @_;
|
|
my ($msg, $output, $err, $errcode, $len);
|
|
|
|
$test_counter++;
|
|
if ($test_begin > $test_counter)
|
|
{
|
|
return 0;
|
|
}
|
|
if ($test_end && $test_end < $test_counter)
|
|
{
|
|
exit(0);
|
|
}
|
|
|
|
$msg= "";
|
|
$expected_error= 0 if (!defined($expected_error));
|
|
|
|
if ($verbose)
|
|
{
|
|
# Print command with out the long unittest/../ prefix
|
|
my $tmp;
|
|
$tmp= $com;
|
|
$tmp =~ s|^unittest/../||;
|
|
print "$tmp ";
|
|
$len= length($tmp);
|
|
}
|
|
$output= `$com 2>&1`;
|
|
if ($verbose && $len <= 62)
|
|
{
|
|
print " " x (62 - $len);
|
|
}
|
|
$err= $?;
|
|
$errcode= ($? >> 8);
|
|
if ((!$err && !$expected_error) ||
|
|
($errcode == $expected_error && $expected_error))
|
|
{
|
|
print "[ " if ($verbose);
|
|
print "ok";
|
|
if ($verbose)
|
|
{
|
|
print " ]";
|
|
print " " x (5 - length("$test_counter"));
|
|
print "$test_counter";
|
|
}
|
|
else
|
|
{
|
|
print " $test_counter - $com"
|
|
}
|
|
print "\n";
|
|
return 1;
|
|
}
|
|
print "[ " if ($verbose);
|
|
print "not ok";
|
|
print " ]" if ($verbose);
|
|
print " $test_counter - $com" unless $verbose;
|
|
print "\n";
|
|
if ($verbose && defined($output) && length($output))
|
|
{
|
|
print "$output\n";
|
|
}
|
|
if (!$verbose)
|
|
{
|
|
$msg= "\n"; # Get a nicer output in perl unit test mode
|
|
}
|
|
$msg.= "Failed test '$com' ";
|
|
if ($iteration)
|
|
{
|
|
$msg.= "(loop iteration $iteration.) ";
|
|
}
|
|
$msg.= "at line ";
|
|
$msg.= (caller)[2];
|
|
$msg.= "\n(errcode: $errcode, test: $test_counter)\n";
|
|
if ($expected_error)
|
|
{
|
|
$msg.= "Was expecting errcode: $expected_error\n";
|
|
}
|
|
warn $msg;
|
|
$runtime_error= 1;
|
|
if ($opt_abort_on_error)
|
|
{
|
|
exit 1;
|
|
}
|
|
# Unlink all files so that we can continue on error
|
|
unlink_all_possible_tmp_files();
|
|
return 0;
|
|
}
|
|
|
|
#
|
|
# Print "skip" and the reason
|
|
#
|
|
# Note: Every time this function is called it will be counted
|
|
# as a unit test.
|
|
#
|
|
# Args: $com: The actual command run. Will be printed on a failure
|
|
# $reason: The reason to skip a test
|
|
# $verbose: Be more verbose.
|
|
#
|
|
|
|
sub skip
|
|
{
|
|
my ($com, $reason, $verbose)= @_;
|
|
|
|
$test_counter++;
|
|
return 0 if $test_begin > $test_counter;
|
|
exit 0 if $test_end && $test_end < $test_counter;
|
|
printf '%-64s[ skipped ]%5d', $com, $test_counter if $verbose;
|
|
print "ok $test_counter # skip $reason" unless $verbose;
|
|
print "\n";
|
|
return 1;
|
|
}
|
|
|
|
####
|
|
#### Count tests
|
|
#### Arguments: $t: an array of the tests
|
|
####
|
|
|
|
sub count_tests
|
|
{
|
|
my ($t)= @_;
|
|
my ($i, $nr_tests);
|
|
|
|
$nr_tests= 0;
|
|
for ($i= 0; defined(@$t[$i]); $i++) { $nr_tests++ if (@$t[$i]); }
|
|
return $nr_tests;
|
|
}
|
|
|
|
sub unlink_log_files
|
|
{
|
|
unlink "$full_tmpdir/aria_log_control", "$full_tmpdir/aria_log.00000001", "$full_tmpdir/aria_log.00000002";
|
|
}
|
|
|
|
sub unlink_all_possible_tmp_files()
|
|
{
|
|
unlink_log_files();
|
|
|
|
# Unlink tmp files that may have been created when testing the test programs
|
|
unlink <$full_tmpdir/*.TMD $full_tmpdir/aria_read_log_test1.txt $full_tmpdir/test1*.MA? $full_tmpdir/ma_test_recovery.output aria_log_control aria_log.00000001 aria_log.00000002 aria_logtest1.MA? test1.MA? test2.MA? test3.MA? *.TMD>;
|
|
}
|
|
|
|
####
|
|
#### Run a bunch of tests
|
|
#### Arguments: $t: an array of the tests
|
|
#### $verbose: to be passed to ok()
|
|
#### $clear: clear log files if set
|
|
####
|
|
|
|
sub run_test_bunch
|
|
{
|
|
my ($t, $verbose, $clear)= @_;
|
|
my ($i);
|
|
|
|
for ($i= 0; defined(@$t[$i]); $i++)
|
|
{
|
|
if ($clear && @$t[$i] eq $NEW_TEST)
|
|
{
|
|
unlink_log_files();
|
|
}
|
|
if (@$t[$i] ne $NEW_TEST)
|
|
{
|
|
ok(@$t[$i], $verbose, $i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
####
|
|
#### usage
|
|
####
|
|
|
|
sub usage
|
|
{
|
|
print <<EOF;
|
|
$my_progname version $VER
|
|
|
|
Description:
|
|
|
|
Run various Aria related tests. Typically used via make test as a unittest.
|
|
|
|
Options
|
|
--help Show this help and exit.
|
|
--abort-on-error Abort at once in case of error.
|
|
--number-of-tests Print the total number of tests and exit.
|
|
--run-tests=... Test range that should be run. You can give just
|
|
one number, to start tests from this test, or a range.
|
|
For example 45..89. To run a specific test alone,
|
|
for example test 215, use --run-tests=215..215
|
|
Use this option with caution, because some of the tests
|
|
might depend on previous ones.
|
|
--start-from=... Alias for --run-tests
|
|
--silent=... Silent option passed to ma_test* tests ('$opt_silent')
|
|
--tmpdir=... Store tests data in this directory (works for most tests)
|
|
--valgrind=... Options for valgrind.
|
|
('$opt_valgrind')
|
|
--verbose Be more verbose. Will print each unittest on a line
|
|
and result after. This mode cannot be used with unit.pl
|
|
when running in normal unit test mode.
|
|
--version Show version number and exit.
|
|
EOF
|
|
exit(0);
|
|
}
|