1: #!/usr/bin/env perl
2: #***************************************************************************
3: # _ _ ____ _
4: # Project ___| | | | _ \| |
5: # / __| | | | |_) | |
6: # | (__| |_| | _ <| |___
7: # \___|\___/|_| \_\_____|
8: #
9: # Copyright (C) 1998 - 2020, Daniel Stenberg, <daniel@haxx.se>, et al.
10: #
11: # This software is licensed as described in the file COPYING, which
12: # you should have received as part of this distribution. The terms
13: # are also available at https://curl.haxx.se/docs/copyright.html.
14: #
15: # You may opt to use, copy, modify, merge, publish, distribute and/or sell
16: # copies of the Software, and permit persons to whom the Software is
17: # furnished to do so, under the terms of the COPYING file.
18: #
19: # This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20: # KIND, either express or implied.
21: #
22: ###########################################################################
23:
24: ###########################
25: # What is This Script?
26: ###########################
27:
28: # testcurl.pl is the master script to use for automatic testing of curl
29: # directly off its source repository.
30: # This is written for the purpose of being run from a crontab job or similar
31: # at a regular interval. The output is suitable to be mailed to
32: # curl-autocompile@haxx.se to be dealt with automatically (make sure the
33: # subject includes the word "autobuild" as the mail gets silently discarded
34: # otherwise). The most current build status (with a reasonable backlog) will
35: # be published on the curl site, at https://curl.haxx.se/auto/
36:
37: # USAGE:
38: # testcurl.pl [options] [curl-daily-name] > output
39:
40: # Options:
41: #
42: # --configure=[options] Configure options
43: # --crosscompile This is a crosscompile
44: # --desc=[desc] Description of your test system
45: # --email=[email] Set email address to report as
46: # --extvercmd=[command] Command to use for displaying version with cross compiles.
47: # --mktarball=[command] Command to run after completed test
48: # --name=[name] Set name to report as
49: # --notes=[notes] More human-readable information about this configuration
50: # --nocvsup Don't pull from git even though it is a git tree
51: # --nogitpull Don't pull from git even though it is a git tree
52: # --nobuildconf Don't run buildconf
53: # --noconfigure Don't run configure
54: # --runtestopts=[options] Options to pass to runtests.pl
55: # --setup=[file name] File name to read setup from (deprecated)
56: # --target=[your os] Specify your target environment.
57: #
58: # if [curl-daily-name] is omitted, a 'curl' git directory is assumed.
59: #
60:
61: use strict;
62:
63: use Cwd;
64: use File::Spec;
65:
66: # Turn on warnings (equivalent to -w, which can't be used with /usr/bin/env)
67: #BEGIN { $^W = 1; }
68:
69: use vars qw($version $fixed $infixed $CURLDIR $git $pwd $build $buildlog
70: $buildlogname $configurebuild $targetos $confheader $binext
71: $libext);
72:
73: use vars qw($name $email $desc $confopts $runtestopts $setupfile $mktarball
74: $extvercmd $nogitpull $nobuildconf $crosscompile
75: $timestamp $notes);
76:
77: # version of this script
78: $version='2014-11-25';
79: $fixed=0;
80:
81: # Determine if we're running from git or a canned copy of curl,
82: # or if we got a specific target option or setup file option.
83: $CURLDIR="curl";
84: if (-f ".git/config") {
85: $CURLDIR = "./";
86: }
87:
88: $git=1;
89: $setupfile = 'setup';
90: $configurebuild = 1;
91: while ($ARGV[0]) {
92: if ($ARGV[0] =~ /--target=/) {
93: $targetos = (split(/=/, shift @ARGV, 2))[1];
94: }
95: elsif ($ARGV[0] =~ /--setup=/) {
96: $setupfile = (split(/=/, shift @ARGV, 2))[1];
97: }
98: elsif ($ARGV[0] =~ /--extvercmd=/) {
99: $extvercmd = (split(/=/, shift @ARGV, 2))[1];
100: }
101: elsif ($ARGV[0] =~ /--mktarball=/) {
102: $mktarball = (split(/=/, shift @ARGV, 2))[1];
103: }
104: elsif ($ARGV[0] =~ /--name=/) {
105: $name = (split(/=/, shift @ARGV, 2))[1];
106: }
107: elsif ($ARGV[0] =~ /--email=/) {
108: $email = (split(/=/, shift @ARGV, 2))[1];
109: }
110: elsif ($ARGV[0] =~ /--desc=/) {
111: $desc = (split(/=/, shift @ARGV, 2))[1];
112: }
113: elsif ($ARGV[0] =~ /--notes=/) {
114: $notes = (split(/=/, shift @ARGV, 2))[1];
115: }
116: elsif ($ARGV[0] =~ /--configure=(.*)/) {
117: $confopts = $1;
118: shift @ARGV;
119: }
120: elsif (($ARGV[0] eq "--nocvsup") || ($ARGV[0] eq "--nogitpull")) {
121: $nogitpull=1;
122: shift @ARGV;
123: }
124: elsif ($ARGV[0] =~ /--nobuildconf/) {
125: $nobuildconf=1;
126: shift @ARGV;
127: }
128: elsif ($ARGV[0] =~ /--noconfigure/) {
129: $configurebuild=0;
130: shift @ARGV;
131: }
132: elsif ($ARGV[0] =~ /--crosscompile/) {
133: $crosscompile=1;
134: shift @ARGV;
135: }
136: elsif ($ARGV[0] =~ /--runtestopts=/) {
137: $runtestopts = (split(/=/, shift @ARGV, 2))[1];
138: }
139: else {
140: $CURLDIR=shift @ARGV;
141: $git=0; # a given dir, assume not using git
142: }
143: }
144:
145: # Do the platform-specific stuff here
146: $confheader = 'curl_config.h';
147: $binext = '';
148: $libext = '.la'; # .la since both libcurl and libcares are made with libtool
149: if ($^O eq 'MSWin32' || $targetos) {
150: if (!$targetos) {
151: # If no target defined on Win32 lets assume vc
152: $targetos = 'vc';
153: }
154: if ($targetos =~ /vc/ || $targetos =~ /borland/ || $targetos =~ /watcom/) {
155: $binext = '.exe';
156: $libext = '.lib';
157: }
158: elsif ($targetos =~ /mingw/) {
159: $binext = '.exe';
160: if ($^O eq 'MSWin32') {
161: $libext = '.a';
162: }
163: }
164: elsif ($targetos =~ /netware/) {
165: $configurebuild = 0;
166: $binext = '.nlm';
167: if ($^O eq 'MSWin32') {
168: $libext = '.lib';
169: }
170: else {
171: $libext = '.a';
172: }
173: }
174: }
175:
176: if (($^O eq 'MSWin32' || $^O eq 'cygwin' || $^O eq 'msys') &&
177: ($targetos =~ /vc/ || $targetos =~ /mingw32/ ||
178: $targetos =~ /borland/ || $targetos =~ /watcom/)) {
179:
180: # Set these things only when building ON Windows and for Win32 platform.
181: # FOR Windows since we might be cross-compiling on another system. Non-
182: # Windows builds still default to configure-style builds with curl_config.h.
183:
184: $configurebuild = 0;
185: $confheader = 'config-win32.h';
186: }
187:
188: $ENV{LC_ALL}="C" if (($ENV{LC_ALL}) && ($ENV{LC_ALL} !~ /^C$/));
189: $ENV{LC_CTYPE}="C" if (($ENV{LC_CTYPE}) && ($ENV{LC_CTYPE} !~ /^C$/));
190: $ENV{LANG}="C";
191:
192: sub rmtree($) {
193: my $target = $_[0];
194: if ($^O eq 'MSWin32') {
195: foreach (glob($target)) {
196: s:/:\\:g;
197: system("rd /s /q $_");
198: }
199: } else {
200: system("rm -rf $target");
201: }
202: }
203:
204: sub grepfile($$) {
205: my ($target, $fn) = @_;
206: open(F, $fn) or die;
207: while (<F>) {
208: if (/$target/) {
209: close(F);
210: return 1;
211: }
212: }
213: close(F);
214: return 0;
215: }
216:
217: sub logit($) {
218: my $text=$_[0];
219: if ($text) {
220: print "testcurl: $text\n";
221: }
222: }
223:
224: sub logit_spaced($) {
225: my $text=$_[0];
226: if ($text) {
227: print "\ntestcurl: $text\n\n";
228: }
229: }
230:
231: sub mydie($){
232: my $text=$_[0];
233: logit "$text";
234: chdir $pwd; # cd back to the original root dir
235:
236: if ($pwd && $build) {
237: # we have a build directory name, remove the dir
238: logit "removing the $build dir";
239: rmtree "$pwd/$build";
240: }
241: if (-r $buildlog) {
242: # we have a build log output file left, remove it
243: logit "removing the $buildlogname file";
244: unlink "$buildlog";
245: }
246: logit "ENDING HERE"; # last line logged!
247: exit 1;
248: }
249:
250: sub get_host_triplet {
251: my $triplet;
252: my $configfile = "$pwd/$build/lib/curl_config.h";
253:
254: if(-f $configfile && -s $configfile && open(LIBCONFIGH, "<$configfile")) {
255: while(<LIBCONFIGH>) {
256: if($_ =~ /^\#define\s+OS\s+"*([^"][^"]*)"*\s*/) {
257: $triplet = $1;
258: last;
259: }
260: }
261: close(LIBCONFIGH);
262: }
263: return $triplet;
264: }
265:
266: if($name && $email && $desc) {
267: # having these fields set are enough to continue, skip reading the setup
268: # file
269: $infixed=4;
270: $fixed=4;
271: }
272: elsif (open(F, "$setupfile")) {
273: while (<F>) {
274: if (/(\w+)=(.*)/) {
275: eval "\$$1=$2;";
276: }
277: }
278: close(F);
279: $infixed=$fixed;
280: }
281: else {
282: $infixed=0; # so that "additional args to configure" works properly first time...
283: }
284:
285: if (!$name) {
286: print "please enter your name\n";
287: $name = <>;
288: chomp $name;
289: $fixed=1;
290: }
291:
292: if (!$email) {
293: print "please enter your contact email address\n";
294: $email = <>;
295: chomp $email;
296: $fixed=2;
297: }
298:
299: if (!$desc) {
300: print "please enter a one line system description\n";
301: $desc = <>;
302: chomp $desc;
303: $fixed=3;
304: }
305:
306: if (!$confopts) {
307: if ($infixed < 4) {
308: print "please enter your additional arguments to configure\n";
309: print "examples: --with-ssl --enable-debug --enable-ipv6 --with-krb4\n";
310: $confopts = <>;
311: chomp $confopts;
312: }
313: }
314:
315:
316: if ($fixed < 4) {
317: $fixed=4;
318: open(F, ">$setupfile") or die;
319: print F "name='$name'\n";
320: print F "email='$email'\n";
321: print F "desc='$desc'\n";
322: print F "confopts='$confopts'\n";
323: print F "notes='$notes'\n";
324: print F "fixed='$fixed'\n";
325: close(F);
326: }
327:
328: # Enable picky compiler warnings unless explicitly disabled
329: if (($confopts !~ /--enable-debug/) &&
330: ($confopts !~ /--enable-warnings/) &&
331: ($confopts !~ /--disable-warnings/)) {
332: $confopts .= " --enable-warnings";
333: }
334:
335: my $str1066os = 'o' x 1066;
336:
337: # Set timestamp to the UTC this script is running. Its value might
338: # be changed later in the script to the value present in curlver.h
339: $timestamp = scalar(gmtime)." UTC";
340:
341: logit "STARTING HERE"; # first line logged, for scripts to trigger on
342: logit 'TRANSFER CONTROL ==== 1120 CHAR LINE' . $str1066os . 'LINE_END';
343: logit "NAME = $name";
344: logit "EMAIL = $email";
345: logit "DESC = $desc";
346: logit "NOTES = $notes";
347: logit "CONFOPTS = $confopts";
348: logit "RUNTESTOPTS = ".$runtestopts;
349: logit "CPPFLAGS = ".$ENV{CPPFLAGS};
350: logit "CFLAGS = ".$ENV{CFLAGS};
351: logit "LDFLAGS = ".$ENV{LDFLAGS};
352: logit "LIBS = ".$ENV{LIBS};
353: logit "CC = ".$ENV{CC};
354: logit "TMPDIR = ".$ENV{TMPDIR};
355: logit "MAKEFLAGS = ".$ENV{MAKEFLAGS};
356: logit "ACLOCAL_FLAGS = ".$ENV{ACLOCAL_FLAGS};
357: logit "PKG_CONFIG_PATH = ".$ENV{PKG_CONFIG_PATH};
358: logit "DYLD_LIBRARY_PATH = ".$ENV{DYLD_LIBRARY_PATH};
359: logit "LD_LIBRARY_PATH = ".$ENV{LD_LIBRARY_PATH};
360: logit "LIBRARY_PATH = ".$ENV{LIBRARY_PATH};
361: logit "SHLIB_PATH = ".$ENV{SHLIB_PATH};
362: logit "LIBPATH = ".$ENV{LIBPATH};
363: logit "target = ".$targetos;
364: logit "version = $version"; # script version
365: logit "date = $timestamp"; # When the test build starts
366:
367: $str1066os = undef;
368:
369: # Make $pwd to become the path without newline. We'll use that in order to cut
370: # off that path from all possible logs and error messages etc.
371: $pwd = getcwd();
372:
373: my $have_embedded_ares = 0;
374:
375: if (-d $CURLDIR) {
376: if ($git && -d "$CURLDIR/.git") {
377: logit "$CURLDIR is verified to be a fine git source dir";
378: # remove the generated sources to force them to be re-generated each
379: # time we run this test
380: unlink "$CURLDIR/src/tool_hugehelp.c";
381: # find out if curl source dir has an in-tree c-ares repo
382: $have_embedded_ares = 1 if (-f "$CURLDIR/ares/GIT-INFO");
383: } elsif (!$git && -f "$CURLDIR/tests/testcurl.pl") {
384: logit "$CURLDIR is verified to be a fine daily source dir";
385: # find out if curl source dir has an in-tree c-ares extracted tarball
386: $have_embedded_ares = 1 if (-f "$CURLDIR/ares/ares_build.h");
387: } else {
388: mydie "$CURLDIR is not a daily source dir or checked out from git!"
389: }
390: }
391:
392: # make the path absolute so we can use it everywhere
393: $CURLDIR = File::Spec->rel2abs("$CURLDIR");
394:
395: $build="build-$$";
396: $buildlogname="buildlog-$$";
397: $buildlog="$pwd/$buildlogname";
398:
399: # remove any previous left-overs
400: rmtree "build-*";
401: rmtree "buildlog-*";
402:
403: # this is to remove old build logs that ended up in the wrong dir
404: foreach (glob("$CURLDIR/buildlog-*")) { unlink $_; }
405:
406: # create a dir to build in
407: mkdir $build, 0777;
408:
409: if (-d $build) {
410: logit "build dir $build was created fine";
411: } else {
412: mydie "failed to create dir $build";
413: }
414:
415: # get in the curl source tree root
416: chdir $CURLDIR;
417:
418: # Do the git thing, or not...
419: if ($git) {
420: my $gitstat = 0;
421: my @commits;
422:
423: # update quietly to the latest git
424: if($nogitpull) {
425: logit "skipping git pull (--nogitpull)";
426: } else {
427: logit "run git pull in curl";
428: system("git pull 2>&1");
429: $gitstat += $?;
430: logit "failed to update from curl git ($?), continue anyway" if ($?);
431:
432: # Set timestamp to the UTC the git update took place.
433: $timestamp = scalar(gmtime)." UTC" if (!$gitstat);
434: }
435:
436: # get the last 5 commits for show (even if no pull was made)
437: @commits=`git log --pretty=oneline --abbrev-commit -5`;
438: logit "The most recent curl git commits:";
439: for (@commits) {
440: chomp ($_);
441: logit " $_";
442: }
443:
444: if (-d "ares/.git") {
445: chdir "ares";
446:
447: if($nogitpull) {
448: logit "skipping git pull (--nogitpull) in ares";
449: } else {
450: logit "run git pull in ares";
451: system("git pull 2>&1");
452: $gitstat += $?;
453: logit "failed to update from ares git ($?), continue anyway" if ($?);
454:
455: # Set timestamp to the UTC the git update took place.
456: $timestamp = scalar(gmtime)." UTC" if (!$gitstat);
457: }
458:
459: # get the last 5 commits for show (even if no pull was made)
460: @commits=`git log --pretty=oneline --abbrev-commit -5`;
461: logit "The most recent ares git commits:";
462: for (@commits) {
463: chomp ($_);
464: logit " $_";
465: }
466:
467: chdir "$CURLDIR";
468: }
469:
470: if($nobuildconf) {
471: logit "told to not run buildconf";
472: }
473: elsif ($configurebuild) {
474: # remove possible left-overs from the past
475: unlink "configure";
476: unlink "autom4te.cache";
477:
478: # generate the build files
479: logit "invoke buildconf";
480: open(F, "./buildconf 2>&1 |") or die;
481: open(LOG, ">$buildlog") or die;
482: while (<F>) {
483: my $ll = $_;
484: # ignore messages pertaining to third party m4 files we don't care
485: next if ($ll =~ /aclocal\/gtk\.m4/);
486: next if ($ll =~ /aclocal\/gtkextra\.m4/);
487: print $ll;
488: print LOG $ll;
489: }
490: close(F);
491: close(LOG);
492:
493: if (grepfile("^buildconf: OK", $buildlog)) {
494: logit "buildconf was successful";
495: }
496: else {
497: mydie "buildconf was NOT successful";
498: }
499: }
500: else {
501: logit "buildconf was successful (dummy message)";
502: }
503: }
504:
505: # Set timestamp to the one in curlver.h if this isn't a git test build.
506: if ((-f "include/curl/curlver.h") &&
507: (open(F, "<include/curl/curlver.h"))) {
508: while (<F>) {
509: chomp;
510: if ($_ =~ /^\#define\s+LIBCURL_TIMESTAMP\s+\"(.+)\".*$/) {
511: my $stampstring = $1;
512: if ($stampstring !~ /DEV/) {
513: $stampstring =~ s/\s+UTC//;
514: $timestamp = $stampstring." UTC";
515: }
516: last;
517: }
518: }
519: close(F);
520: }
521:
522: # Show timestamp we are using for this test build.
523: logit "timestamp = $timestamp";
524:
525: if ($configurebuild) {
526: if (-f "configure") {
527: logit "configure created (at least it exists)";
528: } else {
529: mydie "no configure created/found";
530: }
531: } else {
532: logit "configure created (dummy message)"; # dummy message to feign success
533: }
534:
535: sub findinpath {
536: my $c;
537: my $e;
538: my $x = ($^O eq 'MSWin32') ? '.exe' : '';
539: my $s = ($^O eq 'MSWin32') ? ';' : ':';
540: my $p=$ENV{'PATH'};
541: my @pa = split($s, $p);
542: for $c (@_) {
543: for $e (@pa) {
544: if( -x "$e/$c$x") {
545: return $c;
546: }
547: }
548: }
549: }
550:
551: my $make = findinpath("gmake", "make", "nmake");
552: if(!$make) {
553: mydie "Couldn't find make in the PATH";
554: }
555: # force to 'nmake' for VC builds
556: $make = "nmake" if ($targetos =~ /vc/);
557: # force to 'wmake' for Watcom builds
558: $make = "wmake" if ($targetos =~ /watcom/);
559: logit "going with $make as make";
560:
561: # change to build dir
562: chdir "$pwd/$build";
563:
564: if ($configurebuild) {
565: # run configure script
566: print `$CURLDIR/configure $confopts 2>&1`;
567:
568: if (-f "lib/Makefile") {
569: logit "configure seems to have finished fine";
570: } else {
571: mydie "configure didn't work";
572: }
573: } else {
574: logit "copying files to build dir ...";
575: if (($^O eq 'MSWin32') && ($targetos !~ /netware/)) {
576: system("xcopy /s /q \"$CURLDIR\" .");
577: system("buildconf.bat");
578: }
579: elsif ($targetos =~ /netware/) {
580: system("cp -afr $CURLDIR/* .");
581: system("cp -af $CURLDIR/Makefile.dist Makefile");
582: system("$make -i -C lib -f Makefile.netware prebuild");
583: system("$make -i -C src -f Makefile.netware prebuild");
584: if (-d "$CURLDIR/ares") {
585: system("$make -i -C ares -f Makefile.netware prebuild");
586: }
587: }
588: elsif ($^O eq 'linux') {
589: system("cp -afr $CURLDIR/* .");
590: system("cp -af $CURLDIR/Makefile.dist Makefile");
591: system("$make -i -C lib -f Makefile.$targetos prebuild");
592: system("$make -i -C src -f Makefile.$targetos prebuild");
593: if (-d "$CURLDIR/ares") {
594: system("cp -af $CURLDIR/ares/ares_build.h.dist ./ares/ares_build.h");
595: system("$make -i -C ares -f Makefile.$targetos prebuild");
596: }
597: }
598: }
599:
600: if(-f "./libcurl.pc") {
601: logit_spaced "display libcurl.pc";
602: if(open(F, "<./libcurl.pc")) {
603: while(<F>) {
604: my $ll = $_;
605: print $ll if(($ll !~ /^ *#/) && ($ll !~ /^ *$/));
606: }
607: close(F);
608: }
609: }
610:
611: logit_spaced "display lib/$confheader";
612: open(F, "lib/$confheader") or die "lib/$confheader: $!";
613: while (<F>) {
614: print if /^ *#/;
615: }
616: close(F);
617:
618: if (($have_embedded_ares) &&
619: (grepfile("^#define USE_ARES", "lib/$confheader"))) {
620: print "\n";
621: logit "setup to build ares";
622:
623: if(-f "./ares/libcares.pc") {
624: logit_spaced "display ares/libcares.pc";
625: if(open(F, "<./ares/libcares.pc")) {
626: while(<F>) {
627: my $ll = $_;
628: print $ll if(($ll !~ /^ *#/) && ($ll !~ /^ *$/));
629: }
630: close(F);
631: }
632: }
633:
634: if(-f "./ares/ares_build.h") {
635: logit_spaced "display ares/ares_build.h";
636: if(open(F, "<./ares/ares_build.h")) {
637: while(<F>) {
638: my $ll = $_;
639: print $ll if(($ll =~ /^ *# *define *CARES_/) && ($ll !~ /__CARES_BUILD_H/));
640: }
641: close(F);
642: }
643: }
644: else {
645: mydie "no ares_build.h created/found";
646: }
647:
648: $confheader =~ s/curl/ares/;
649: logit_spaced "display ares/$confheader";
650: if(open(F, "ares/$confheader")) {
651: while (<F>) {
652: print if /^ *#/;
653: }
654: close(F);
655: }
656:
657: print "\n";
658: logit "build ares";
659: chdir "ares";
660:
661: if ($targetos && !$configurebuild) {
662: logit "$make -f Makefile.$targetos";
663: open(F, "$make -f Makefile.$targetos 2>&1 |") or die;
664: }
665: else {
666: logit "$make";
667: open(F, "$make 2>&1 |") or die;
668: }
669: while (<F>) {
670: s/$pwd//g;
671: print;
672: }
673: close(F);
674:
675: if (-f "libcares$libext") {
676: logit "ares is now built successfully (libcares$libext)";
677: } else {
678: mydie "ares build failed (libcares$libext)";
679: }
680:
681: # cd back to the curl build dir
682: chdir "$pwd/$build";
683: }
684:
685: my $mkcmd = "$make -i" . ($targetos && !$configurebuild ? " $targetos" : "");
686: logit "$mkcmd";
687: open(F, "$mkcmd 2>&1 |") or die;
688: while (<F>) {
689: s/$pwd//g;
690: print;
691: }
692: close(F);
693:
694: if (-f "lib/libcurl$libext") {
695: logit "libcurl was created fine (libcurl$libext)";
696: }
697: else {
698: mydie "libcurl was not created (libcurl$libext)";
699: }
700:
701: if (-f "src/curl$binext") {
702: logit "curl was created fine (curl$binext)";
703: }
704: else {
705: mydie "curl was not created (curl$binext)";
706: }
707:
708: if (!$crosscompile || (($extvercmd ne '') && (-x $extvercmd))) {
709: logit "display curl${binext} --version output";
710: my $cmd = ($extvercmd ne '' ? $extvercmd.' ' : '')."./src/curl${binext} --version|";
711: open(F, $cmd);
712: while(<F>) {
713: # strip CR from output on non-win32 platforms (wine on Linux)
714: s/\r// if ($^O ne 'MSWin32');
715: print;
716: }
717: close(F);
718: }
719:
720: if ($configurebuild && !$crosscompile) {
721: my $host_triplet = get_host_triplet();
722: # build example programs for selected build targets
723: if(($host_triplet =~ /([^-]+)-([^-]+)-irix(.*)/) ||
724: ($host_triplet =~ /([^-]+)-([^-]+)-aix(.*)/) ||
725: ($host_triplet =~ /([^-]+)-([^-]+)-osf(.*)/) ||
726: ($host_triplet =~ /([^-]+)-([^-]+)-solaris2(.*)/)) {
727: chdir "$pwd/$build/docs/examples";
728: logit_spaced "build examples";
729: open(F, "$make -i 2>&1 |") or die;
730: open(LOG, ">$buildlog") or die;
731: while (<F>) {
732: s/$pwd//g;
733: print;
734: print LOG;
735: }
736: close(F);
737: close(LOG);
738: chdir "$pwd/$build";
739: }
740: # build and run full test suite
741: my $o;
742: if($runtestopts) {
743: $o = "TEST_F=\"$runtestopts\" ";
744: }
745: logit "$make -k ${o}test-full";
746: open(F, "$make -k ${o}test-full 2>&1 |") or die;
747: open(LOG, ">$buildlog") or die;
748: while (<F>) {
749: s/$pwd//g;
750: print;
751: print LOG;
752: }
753: close(F);
754: close(LOG);
755:
756: if (grepfile("^TEST", $buildlog)) {
757: logit "tests were run";
758: } else {
759: mydie "test suite failure";
760: }
761:
762: if (grepfile("^TESTFAIL:", $buildlog)) {
763: logit "the tests were not successful";
764: } else {
765: logit "the tests were successful!";
766: }
767: }
768: else {
769: if($crosscompile) {
770: my $host_triplet = get_host_triplet();
771: # build example programs for selected cross-compiles
772: if(($host_triplet =~ /([^-]+)-([^-]+)-mingw(.*)/) ||
773: ($host_triplet =~ /([^-]+)-([^-]+)-android(.*)/)) {
774: chdir "$pwd/$build/docs/examples";
775: logit_spaced "build examples";
776: open(F, "$make -i 2>&1 |") or die;
777: open(LOG, ">$buildlog") or die;
778: while (<F>) {
779: s/$pwd//g;
780: print;
781: print LOG;
782: }
783: close(F);
784: close(LOG);
785: chdir "$pwd/$build";
786: }
787: # build test harness programs for selected cross-compiles
788: if($host_triplet =~ /([^-]+)-([^-]+)-mingw(.*)/) {
789: chdir "$pwd/$build/tests";
790: logit_spaced "build test harness";
791: open(F, "$make -i 2>&1 |") or die;
792: open(LOG, ">$buildlog") or die;
793: while (<F>) {
794: s/$pwd//g;
795: print;
796: print LOG;
797: }
798: close(F);
799: close(LOG);
800: chdir "$pwd/$build";
801: }
802: logit_spaced "cross-compiling, can't run tests";
803: }
804: # dummy message to feign success
805: print "TESTDONE: 1 tests out of 0 (dummy message)\n";
806: }
807:
808: # create a tarball if we got that option.
809: if (($mktarball ne '') && (-x $mktarball)) {
810: system($mktarball);
811: }
812:
813: # mydie to cleanup
814: mydie "ending nicely";
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testcurl.pl CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / tests