diff options
author | Igor Pashev <pashev.igor@gmail.com> | 2012-08-26 19:24:46 +0400 |
---|---|---|
committer | Igor Pashev <pashev.igor@gmail.com> | 2012-08-26 19:24:46 +0400 |
commit | e46c9ea201b4bad8f4c6d19ee6dfb3537bc9facd (patch) | |
tree | 26ae9736985be2ef61032e7808b9fb0e2155c71f /tests/run_make_tests.pl | |
download | make.old-e46c9ea201b4bad8f4c6d19ee6dfb3537bc9facd.tar.gz |
Imported GNU Make 3.81upstream/3.82upstream
Diffstat (limited to 'tests/run_make_tests.pl')
-rwxr-xr-x | tests/run_make_tests.pl | 402 |
1 files changed, 402 insertions, 0 deletions
diff --git a/tests/run_make_tests.pl b/tests/run_make_tests.pl new file mode 100755 index 0000000..2c8c08b --- /dev/null +++ b/tests/run_make_tests.pl @@ -0,0 +1,402 @@ +#!/usr/bin/env perl +# -*-perl-*- + +# Test driver for the Make test suite + +# Usage: run_make_tests [testname] +# [-debug] +# [-help] +# [-verbose] +# [-keep] +# [-make <make prog>] +# (and others) + +# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, +# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software +# Foundation, Inc. +# This file is part of GNU Make. +# +# GNU Make is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License as published by the Free Software +# Foundation; either version 3 of the License, or (at your option) any later +# version. +# +# GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +# details. +# +# You should have received a copy of the GNU General Public License along with +# this program. If not, see <http://www.gnu.org/licenses/>. + + +$valgrind = 0; # invoke make with valgrind +$valgrind_args = ''; +$memcheck_args = '--num-callers=15 --tool=memcheck --leak-check=full'; +$massif_args = '--num-callers=15 --tool=massif --alloc-fn=xmalloc --alloc-fn=xcalloc --alloc-fn=xrealloc --alloc-fn=xstrdup --alloc-fn=xstrndup'; +$pure_log = undef; + +$command_string = ''; + +$all_tests = 0; + +require "test_driver.pl"; + +# Some target systems might not have the POSIX module... +$has_POSIX = eval { require "POSIX.pm" }; + +#$SIG{INT} = sub { print STDERR "Caught a signal!\n"; die @_; }; + +sub valid_option +{ + local($option) = @_; + + if ($option =~ /^-make([-_]?path)?$/i) { + $make_path = shift @argv; + if (!-f $make_path) { + print "$option $make_path: Not found.\n"; + exit 0; + } + return 1; + } + + if ($option =~ /^-all([-_]?tests)?$/i) { + $all_tests = 1; + return 1; + } + + if ($option =~ /^-(valgrind|memcheck)$/i) { + $valgrind = 1; + $valgrind_args = $memcheck_args; + return 1; + } + + if ($option =~ /^-massif$/i) { + $valgrind = 1; + $valgrind_args = $massif_args; + return 1; + } + +# This doesn't work--it _should_! Someone badly needs to fix this. +# +# elsif ($option =~ /^-work([-_]?dir)?$/) +# { +# $workdir = shift @argv; +# return 1; +# } + + return 0; +} + + +# This is an "all-in-one" function. Arguments are as follows: +# +# [0] (string): The makefile to be tested. undef means use the last one. +# [1] (string): Arguments to pass to make. +# [2] (string): Answer we should get back. +# [3] (integer): Exit code we expect. A missing code means 0 (success) + +$old_makefile = undef; + +sub run_make_test +{ + local ($makestring, $options, $answer, $err_code, $timeout) = @_; + + # If the user specified a makefile string, create a new makefile to contain + # it. If the first value is not defined, use the last one (if there is + # one). + + if (! defined $makestring) { + defined $old_makefile + || die "run_make_test(undef) invoked before run_make_test('...')\n"; + $makefile = $old_makefile; + } else { + if (! defined($makefile)) { + $makefile = &get_tmpfile(); + } + + # Make sure it ends in a newline. + $makestring && $makestring !~ /\n$/s and $makestring .= "\n"; + + # Replace @MAKEFILE@ with the makefile name and @MAKE@ with the path to + # make + $makestring =~ s/#MAKEFILE#/$makefile/g; + $makestring =~ s/#MAKEPATH#/$mkpath/g; + $makestring =~ s/#MAKE#/$make_name/g; + $makestring =~ s/#PERL#/$perl_name/g; + $makestring =~ s/#PWD#/$pwd/g; + + # Populate the makefile! + open(MAKEFILE, "> $makefile") || die "Failed to open $makefile: $!\n"; + print MAKEFILE $makestring; + close(MAKEFILE) || die "Failed to write $makefile: $!\n"; + } + + # Do the same processing on $answer as we did on $makestring. + + $answer && $answer !~ /\n$/s and $answer .= "\n"; + $answer =~ s/#MAKEFILE#/$makefile/g; + $answer =~ s/#MAKEPATH#/$mkpath/g; + $answer =~ s/#MAKE#/$make_name/g; + $answer =~ s/#PERL#/$perl_name/g; + $answer =~ s/#PWD#/$pwd/g; + + run_make_with_options($makefile, $options, &get_logfile(0), + $err_code, $timeout); + &compare_output($answer, &get_logfile(1)); + + $old_makefile = $makefile; + $makefile = undef; +} + +# The old-fashioned way... +sub run_make_with_options { + local ($filename,$options,$logname,$expected_code,$timeout) = @_; + local($code); + local($command) = $make_path; + + $expected_code = 0 unless defined($expected_code); + + # Reset to reflect this one test. + $test_passed = 1; + + if ($filename) { + $command .= " -f $filename"; + } + + if ($options) { + $command .= " $options"; + } + + $command_string = "$command\n"; + + if ($valgrind) { + print VALGRIND "\n\nExecuting: $command\n"; + } + + + { + my $old_timeout = $test_timeout; + $timeout and $test_timeout = $timeout; + + # If valgrind is enabled, turn off the timeout check + $valgrind and $test_timeout = 0; + + $code = &run_command_with_output($logname,$command); + + $test_timeout = $old_timeout; + } + + # Check to see if we have Purify errors. If so, keep the logfile. + # For this to work you need to build with the Purify flag -exit-status=yes + + if ($pure_log && -f $pure_log) { + if ($code & 0x7000) { + $code &= ~0x7000; + + # If we have a purify log, save it + $tn = $pure_testname . ($num_of_logfiles ? ".$num_of_logfiles" : ""); + print("Renaming purify log file to $tn\n") if $debug; + rename($pure_log, "$tn") + || die "Can't rename $log to $tn: $!\n"; + ++$purify_errors; + } else { + unlink($pure_log); + } + } + + if ($code != $expected_code) { + print "Error running $make_path (expected $expected_code; got $code): $command\n"; + $test_passed = 0; + $runf = &get_runfile; + &create_file (&get_runfile, $command_string); + # If it's a SIGINT, stop here + if ($code & 127) { + print STDERR "\nCaught signal ".($code & 127)."!\n"; + ($code & 127) == 2 and exit($code); + } + return 0; + } + + if ($profile & $vos) { + system "add_profile $make_path"; + } + + return 1; +} + +sub print_usage +{ + &print_standard_usage ("run_make_tests", + "[-make_path make_pathname] [-memcheck] [-massif]",); +} + +sub print_help +{ + &print_standard_help ( + "-make_path", + "\tYou may specify the pathname of the copy of make to run.", + "-valgrind", + "-memcheck", + "\tRun the test suite under valgrind's memcheck tool.", + "\tChange the default valgrind args with the VALGRIND_ARGS env var.", + "-massif", + "\tRun the test suite under valgrind's massif toool.", + "\tChange the default valgrind args with the VALGRIND_ARGS env var." + ); +} + +sub get_this_pwd { + $delete_command = 'rm -f'; + if ($has_POSIX) { + $__pwd = POSIX::getcwd(); + } elsif ($vos) { + $delete_command = "delete_file -no_ask"; + $__pwd = `++(current_dir)`; + } else { + # No idea... just try using pwd as a last resort. + chop ($__pwd = `pwd`); + } + + return $__pwd; +} + +sub set_defaults +{ + # $profile = 1; + $testee = "GNU make"; + $make_path = "make"; + $tmpfilesuffix = "mk"; + $pwd = &get_this_pwd; +} + +sub set_more_defaults +{ + local($string); + local($index); + + # find the type of the port. We do this up front to have a single + # point of change if it needs to be tweaked. + # + # This is probably not specific enough. + # + if ($osname =~ /Windows/i || $osname =~ /MINGW32/i || $osname =~ /CYGWIN_NT/i) { + $port_type = 'W32'; + } + # Bleah, the osname is so variable on DOS. This kind of bites. + # Well, as far as I can tell if we check for some text at the + # beginning of the line with either no spaces or a single space, then + # a D, then either "OS", "os", or "ev" and a space. That should + # match and be pretty specific. + elsif ($osname =~ /^([^ ]*|[^ ]* [^ ]*)D(OS|os|ev) /) { + $port_type = 'DOS'; + } + # Check for OS/2 + elsif ($osname =~ m%OS/2%) { + $port_type = 'OS/2'; + } + # Everything else, right now, is UNIX. Note that we should integrate + # the VOS support into this as well and get rid of $vos; we'll do + # that next time. + else { + $port_type = 'UNIX'; + } + + # On DOS/Windows system the filesystem apparently can't track + # timestamps with second granularity (!!). Change the sleep time + # needed to force a file to be considered "old". + $wtime = $port_type eq 'UNIX' ? 1 : $port_type eq 'OS/2' ? 2 : 4; + + print "Port type: $port_type\n" if $debug; + print "Make path: $make_path\n" if $debug; + + # Find the full pathname of Make. For DOS systems this is more + # complicated, so we ask make itself. + my $mk = `sh -c 'echo "all:;\@echo \\\$(MAKE)" | $make_path -f-'`; + chop $mk; + $mk or die "FATAL ERROR: Cannot determine the value of \$(MAKE):\n +'echo \"all:;\@echo \\\$(MAKE)\" | $make_path -f-' failed!\n"; + $make_path = $mk; + print "Make\t= `$make_path'\n" if $debug; + + $string = `$make_path -v -f /dev/null 2> /dev/null`; + + $string =~ /^(GNU Make [^,\n]*)/; + $testee_version = "$1\n"; + + $string = `sh -c "$make_path -f /dev/null 2>&1"`; + if ($string =~ /(.*): \*\*\* No targets\. Stop\./) { + $make_name = $1; + } + else { + if ($make_path =~ /$pathsep([^\n$pathsep]*)$/) { + $make_name = $1; + } + else { + $make_name = $make_path; + } + } + + # prepend pwd if this is a relative path (ie, does not + # start with a slash, but contains one). Thanks for the + # clue, Roland. + + if (index ($make_path, ":") != 1 && index ($make_path, "/") > 0) + { + $mkpath = "$pwd$pathsep$make_path"; + } + else + { + $mkpath = $make_path; + } + + # Get Purify log info--if any. + + if (exists $ENV{PURIFYOPTIONS} + && $ENV{PURIFYOPTIONS} =~ /.*-logfile=([^ ]+)/) { + $pure_log = $1 || ''; + $pure_log =~ s/%v/$make_name/; + $purify_errors = 0; + } + + $string = `sh -c "$make_path -j 2 -f /dev/null 2>&1"`; + if ($string =~ /not supported/) { + $parallel_jobs = 0; + } + else { + $parallel_jobs = 1; + } + + # Set up for valgrind, if requested. + + if ($valgrind) { + my $args = $valgrind_args; + open(VALGRIND, "> valgrind.out") + || die "Cannot open valgrind.out: $!\n"; + # -q --leak-check=yes + exists $ENV{VALGRIND_ARGS} and $args = $ENV{VALGRIND_ARGS}; + $make_path = "valgrind --log-fd=".fileno(VALGRIND)." $args $make_path"; + # F_SETFD is 2 + fcntl(VALGRIND, 2, 0) or die "fcntl(setfd) failed: $!\n"; + system("echo Starting on `date` 1>&".fileno(VALGRIND)); + print "Enabled valgrind support.\n"; + } +} + +sub setup_for_test +{ + $makefile = &get_tmpfile; + if (-f $makefile) { + unlink $makefile; + } + + # Get rid of any Purify logs. + if ($pure_log) { + ($pure_testname = $testname) =~ tr,/,_,; + $pure_testname = "$pure_log.$pure_testname"; + system("rm -f $pure_testname*"); + print("Purify testfiles are: $pure_testname*\n") if $debug; + } +} + +exit !&toplevel; |