1#! /bin/sh 2 3############################################################################### 4# Run the PCRE2 tests using the pcre2test program. The appropriate tests are 5# selected, depending on which build-time options were used. 6# 7# When JIT support is available, all appropriate tests are run with and without 8# JIT, unless "-nojit" is given on the command line. There are also two tests 9# for JIT-specific features, one to be run when JIT support is available 10# (unless "-nojit" is specified), and one when it is not. 11# 12# Whichever of the 8-, 16- and 32-bit libraries exist are tested. It is also 13# possible to select which to test by giving "-8", "-16" or "-32" on the 14# command line. 15# 16# As well as "-nojit", "-8", "-16", and "-32", arguments for this script are 17# individual test numbers, ranges of tests such as 3-6 or 3- (meaning 3 to the 18# end), or a number preceded by ~ to exclude a test. For example, "3-15 ~10" 19# runs tests 3 to 15, excluding test 10, and just "~10" runs all the tests 20# except test 10. Whatever order the arguments are in, the tests are always run 21# in numerical order. 22# 23# Inappropriate tests are automatically skipped (with a comment to say so). For 24# example, if JIT support is not compiled, test 16 is skipped, whereas if JIT 25# support is compiled, test 15 is skipped. 26# 27# Other arguments can be one of the words "-valgrind", "-valgrind-log", or 28# "-sim" followed by an argument to run cross-compiled executables under a 29# simulator, for example: 30# 31# RunTest 3 -sim "qemu-arm -s 8388608" 32# 33# For backwards compatibility, -nojit, -valgrind, -valgrind-log, and -sim may 34# be given without the leading "-" character. 35# 36# When PCRE2 is compiled by clang with -fsanitize arguments, some tests need 37# very much more stack than normal. In environments where the stack can be 38# set at runtime, -bigstack sets a gigantic stack. 39# 40# There are two special cases where only one argument is allowed: 41# 42# If the first and only argument is "ebcdic", the script runs the special 43# EBCDIC test that can be useful for checking certain EBCDIC features, even 44# when run in an ASCII environment. PCRE2 must be built with EBCDIC support for 45# this test to be run. 46# 47# If the script is obeyed as "RunTest list", a list of available tests is 48# output, but none of them are run. 49############################################################################### 50 51# Define test titles in variables so that they can be output as a list. Some 52# of them are modified (e.g. with -8 or -16) when used in the actual tests. 53 54title0="Test 0: Unchecked pcre2test argument tests (to improve coverage)" 55title1="Test 1: Main non-UTF, non-UCP functionality (compatible with Perl >= 5.10)" 56title2="Test 2: API, errors, internals and non-Perl stuff" 57title3="Test 3: Locale-specific features" 58title4A="Test 4: UTF" 59title4B=" and Unicode property support (compatible with Perl >= 5.10)" 60title5A="Test 5: API, internals, and non-Perl stuff for UTF" 61title5B=" and UCP support" 62title6="Test 6: DFA matching main non-UTF, non-UCP functionality" 63title7A="Test 7: DFA matching with UTF" 64title7B=" and Unicode property support" 65title8="Test 8: Internal offsets and code size tests" 66title9="Test 9: Specials for the basic 8-bit library" 67title10="Test 10: Specials for the 8-bit library with UTF-8 and UCP support" 68title11="Test 11: Specials for the basic 16-bit and 32-bit libraries" 69title12="Test 12: Specials for the 16-bit and 32-bit libraries UTF and UCP support" 70title13="Test 13: DFA specials for the basic 16-bit and 32-bit libraries" 71title14="Test 14: DFA specials for UTF and UCP support" 72title15="Test 15: Non-JIT limits and other non-JIT tests" 73title16="Test 16: JIT-specific features when JIT is not available" 74title17="Test 17: JIT-specific features when JIT is available" 75title18="Test 18: Tests of the POSIX interface, excluding UTF/UCP" 76title19="Test 19: Tests of the POSIX interface with UTF/UCP" 77title20="Test 20: Serialization and code copy tests" 78title21="Test 21: \C tests without UTF (supported for DFA matching)" 79title22="Test 22: \C tests with UTF (not supported for DFA matching)" 80title23="Test 23: \C disabled test" 81title24="Test 24: Non-UTF pattern conversion tests" 82title25="Test 25: UTF pattern conversion tests" 83maxtest=25 84 85if [ $# -eq 1 -a "$1" = "list" ]; then 86 echo $title0 87 echo $title1 88 echo $title2 "(not UTF or UCP)" 89 echo $title3 90 echo $title4A $title4B 91 echo $title5A $title5B 92 echo $title6 93 echo $title7A $title7B 94 echo $title8 95 echo $title9 96 echo $title10 97 echo $title11 98 echo $title12 99 echo $title13 100 echo $title14 101 echo $title15 102 echo $title16 103 echo $title17 104 echo $title18 105 echo $title19 106 echo $title20 107 echo $title21 108 echo $title22 109 echo $title23 110 echo $title24 111 echo $title25 112 exit 0 113fi 114 115# Set up a suitable "diff" command for comparison. Some systems 116# have a diff that lacks a -u option. Try to deal with this. 117 118cf="diff" 119diff -u /dev/null /dev/null 2>/dev/null && cf="diff -u" 120 121# Find the test data 122 123if [ -n "$srcdir" -a -d "$srcdir" ] ; then 124 testdata="$srcdir/testdata" 125elif [ -d "./testdata" ] ; then 126 testdata=./testdata 127elif [ -d "../testdata" ] ; then 128 testdata=../testdata 129else 130 echo "Cannot find the testdata directory" 131 exit 1 132fi 133 134 135# ------ Function to check results of a test ------- 136 137# This function is called with three parameters: 138# 139# $1 the value of $? after a call to pcre2test 140# $2 the suffix of the output file to compare with 141# $3 the $opt value (empty, -jit, or -dfa) 142# 143# Note: must define using name(), not "function name", for Solaris. 144 145checkresult() 146 { 147 if [ $1 -ne 0 ] ; then 148 echo "** pcre2test failed - check testtry" 149 exit 1 150 fi 151 case "$3" in 152 -jit) with=" with JIT";; 153 -dfa) with=" with DFA";; 154 *) with="";; 155 esac 156 $cf $testdata/testoutput$2 testtry 157 if [ $? != 0 ] ; then 158 echo "" 159 echo "** Test $2 failed$with" 160 exit 1 161 fi 162 echo " OK$with" 163 } 164 165 166# ------ Function to run and check a special pcre2test arguments test ------- 167 168checkspecial() 169 { 170 $valgrind $vjs ./pcre2test $1 >>testtry 171 if [ $? -ne 0 ] ; then 172 echo "** pcre2test $1 failed - check testtry" 173 exit 1 174 fi 175 } 176 177 178# ------ Special EBCDIC Test ------- 179 180if [ $# -eq 1 -a "$1" = "ebcdic" ]; then 181 $valgrind ./pcre2test -C ebcdic >/dev/null 182 ebcdic=$? 183 if [ $ebcdic -ne 1 ] ; then 184 echo "Cannot run EBCDIC tests: EBCDIC support not compiled" 185 exit 1 186 fi 187 for opt in "" "-dfa"; do 188 ./pcre2test -q $opt $testdata/testinputEBC >testtry 189 checkresult $? EBC "$opt" 190 done 191exit 0 192fi 193 194 195# ------ Normal Tests ------ 196 197# Default values 198 199arg8= 200arg16= 201arg32= 202nojit= 203bigstack= 204sim= 205skip= 206valgrind= 207vjs= 208 209# This is in case the caller has set aliases (as I do - PH) 210unset cp ls mv rm 211 212# Process options and select which tests to run; for those that are explicitly 213# requested, check that the necessary optional facilities are available. 214 215do0=no 216do1=no 217do2=no 218do3=no 219do4=no 220do5=no 221do6=no 222do7=no 223do8=no 224do9=no 225do10=no 226do11=no 227do12=no 228do13=no 229do14=no 230do15=no 231do16=no 232do17=no 233do18=no 234do19=no 235do20=no 236do21=no 237do22=no 238do23=no 239do24=no 240do25=no 241 242while [ $# -gt 0 ] ; do 243 case $1 in 244 0) do0=yes;; 245 1) do1=yes;; 246 2) do2=yes;; 247 3) do3=yes;; 248 4) do4=yes;; 249 5) do5=yes;; 250 6) do6=yes;; 251 7) do7=yes;; 252 8) do8=yes;; 253 9) do9=yes;; 254 10) do10=yes;; 255 11) do11=yes;; 256 12) do12=yes;; 257 13) do13=yes;; 258 14) do14=yes;; 259 15) do15=yes;; 260 16) do16=yes;; 261 17) do17=yes;; 262 18) do18=yes;; 263 19) do19=yes;; 264 20) do20=yes;; 265 21) do21=yes;; 266 22) do22=yes;; 267 23) do23=yes;; 268 24) do24=yes;; 269 25) do25=yes;; 270 -8) arg8=yes;; 271 -16) arg16=yes;; 272 -32) arg32=yes;; 273 bigstack|-bigstack) bigstack=yes;; 274 nojit|-nojit) nojit=yes;; 275 sim|-sim) shift; sim=$1;; 276 valgrind|-valgrind) valgrind="valgrind --tool=memcheck -q --smc-check=all-non-file";; 277 valgrind-log|-valgrind-log) valgrind="valgrind --tool=memcheck --num-callers=30 --leak-check=no --error-limit=no --smc-check=all-non-file --log-file=report.%p ";; 278 ~*) 279 if expr "$1" : '~[0-9][0-9]*$' >/dev/null; then 280 skip="$skip `expr "$1" : '~\([0-9]*\)*$'`" 281 else 282 echo "Unknown option or test selector '$1'"; exit 1 283 fi 284 ;; 285 *-*) 286 if expr "$1" : '[0-9][0-9]*-[0-9]*$' >/dev/null; then 287 tf=`expr "$1" : '\([0-9]*\)'` 288 tt=`expr "$1" : '.*-\([0-9]*\)'` 289 if [ "$tt" = "" ] ; then tt=$maxtest; fi 290 if expr \( "$tt" ">" "$maxtest" \) >/dev/null; then 291 echo "Invalid test range '$1'"; exit 1 292 fi 293 while expr "$tf" "<=" "$tt" >/dev/null; do 294 eval do${tf}=yes 295 tf=`expr $tf + 1` 296 done 297 else 298 echo "Invalid test range '$1'"; exit 1 299 fi 300 ;; 301 *) echo "Unknown option or test selector '$1'"; exit 1;; 302 esac 303 shift 304done 305 306# Find which optional facilities are available. 307 308$sim ./pcre2test -C linksize >/dev/null 309link_size=$? 310if [ $link_size -lt 2 ] ; then 311 echo "RunTest: Failed to find internal link size" 312 exit 1 313fi 314if [ $link_size -gt 4 ] ; then 315 echo "RunTest: Failed to find internal link size" 316 exit 1 317fi 318 319# If it is possible to set the system stack size and -bigstack was given, 320# set up a large stack. 321 322$sim ./pcre2test -S 64 /dev/null /dev/null 323if [ $? -eq 0 -a "$bigstack" != "" ] ; then 324 setstack="-S 64" 325else 326 setstack="" 327fi 328 329# All of 8-bit, 16-bit, and 32-bit character strings may be supported, but only 330# one need be. 331 332$sim ./pcre2test -C pcre2-8 >/dev/null 333support8=$? 334$sim ./pcre2test -C pcre2-16 >/dev/null 335support16=$? 336$sim ./pcre2test -C pcre2-32 >/dev/null 337support32=$? 338 339# \C may be disabled 340 341$sim ./pcre2test -C backslash-C >/dev/null 342supportBSC=$? 343 344# Initialize all bitsizes skipped 345 346test8=skip 347test16=skip 348test32=skip 349 350# If no bitsize arguments, select all that are available 351 352if [ "$arg8$arg16$arg32" = "" ] ; then 353 if [ $support8 -ne 0 ] ; then 354 test8=-8 355 fi 356 if [ $support16 -ne 0 ] ; then 357 test16=-16 358 fi 359 if [ $support32 -ne 0 ] ; then 360 test32=-32 361 fi 362 363# Otherwise, select requested bit sizes 364 365else 366 if [ "$arg8" = yes ] ; then 367 if [ $support8 -eq 0 ] ; then 368 echo "Cannot run 8-bit library tests: 8-bit library not compiled" 369 exit 1 370 fi 371 test8=-8 372 fi 373 if [ "$arg16" = yes ] ; then 374 if [ $support16 -eq 0 ] ; then 375 echo "Cannot run 16-bit library tests: 16-bit library not compiled" 376 exit 1 377 fi 378 test16=-16 379 fi 380 if [ "$arg32" = yes ] ; then 381 if [ $support32 -eq 0 ] ; then 382 echo "Cannot run 32-bit library tests: 32-bit library not compiled" 383 exit 1 384 fi 385 test32=-32 386 fi 387fi 388 389# UTF support is implied by Unicode support, and it always applies to all bit 390# sizes if both are supported; we can't have UTF-8 support without UTF-16 or 391# UTF-32 support. 392 393$sim ./pcre2test -C unicode >/dev/null 394utf=$? 395 396# When JIT is used with valgrind, we need to set up valgrind suppressions as 397# otherwise there are a lot of false positive valgrind reports when the 398# the hardware supports SSE2. 399 400jitopt= 401$sim ./pcre2test -C jit >/dev/null 402jit=$? 403if [ $jit -ne 0 -a "$nojit" != "yes" ] ; then 404 jitopt=-jit 405 if [ "$valgrind" != "" ] ; then 406 vjs="--suppressions=$testdata/valgrind-jit.supp" 407 fi 408fi 409 410# If no specific tests were requested, select all. Those that are not 411# relevant will be automatically skipped. 412 413if [ $do0 = no -a $do1 = no -a $do2 = no -a $do3 = no -a \ 414 $do4 = no -a $do5 = no -a $do6 = no -a $do7 = no -a \ 415 $do8 = no -a $do9 = no -a $do10 = no -a $do11 = no -a \ 416 $do12 = no -a $do13 = no -a $do14 = no -a $do15 = no -a \ 417 $do16 = no -a $do17 = no -a $do18 = no -a $do19 = no -a \ 418 $do20 = no -a $do21 = no -a $do22 = no -a $do23 = no -a \ 419 $do24 = no -a $do25 = no \ 420 ]; then 421 do0=yes 422 do1=yes 423 do2=yes 424 do3=yes 425 do4=yes 426 do5=yes 427 do6=yes 428 do7=yes 429 do8=yes 430 do9=yes 431 do10=yes 432 do11=yes 433 do12=yes 434 do13=yes 435 do14=yes 436 do15=yes 437 do16=yes 438 do17=yes 439 do18=yes 440 do19=yes 441 do20=yes 442 do21=yes 443 do22=yes 444 do23=yes 445 do24=yes 446 do25=yes 447fi 448 449# Handle any explicit skips at this stage, so that an argument list may consist 450# only of explicit skips. 451 452for i in $skip; do eval do$i=no; done 453 454# Show which release and which test data 455 456echo "" 457echo PCRE2 C library tests using test data from $testdata 458$sim ./pcre2test /dev/null 459echo "" 460 461for bmode in "$test8" "$test16" "$test32"; do 462 case "$bmode" in 463 skip) continue;; 464 -16) if [ "$test8$test32" != "skipskip" ] ; then echo ""; fi 465 bits=16; echo "---- Testing 16-bit library ----"; echo "";; 466 -32) if [ "$test8$test16" != "skipskip" ] ; then echo ""; fi 467 bits=32; echo "---- Testing 32-bit library ----"; echo "";; 468 -8) bits=8; echo "---- Testing 8-bit library ----"; echo "";; 469 esac 470 471 # Test 0 is a special test. Its output is not checked, because it will 472 # be different on different hardware and with different configurations. 473 # Running this test just exercises the code. 474 475 if [ $do0 = yes ] ; then 476 echo $title0 477 echo '/abc/jit,memory,framesize' >testSinput 478 echo ' abc' >>testSinput 479 echo '' >testtry 480 checkspecial '-C' 481 checkspecial '--help' 482 checkspecial '-S 1 -t 10 testSinput' 483 echo " OK" 484 fi 485 486 # Primary non-UTF test, compatible with JIT and all versions of Perl >= 5.8 487 488 if [ $do1 = yes ] ; then 489 echo $title1 490 for opt in "" $jitopt; do 491 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput1 testtry 492 checkresult $? 1 "$opt" 493 done 494 fi 495 496 # PCRE2 tests that are not Perl-compatible: API, errors, internals. We copy 497 # the testbtables file to the current directory for use by this test. 498 499 if [ $do2 = yes ] ; then 500 echo $title2 "(excluding UTF-$bits)" 501 cp $testdata/testbtables . 502 for opt in "" $jitopt; do 503 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput2 testtry 504 saverc=$? 505 if [ $saverc = 0 ] ; then 506 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $bmode $opt -error -70,-62,-2,-1,0,100,101,191,200 >>testtry 507 checkresult $? 2 "$opt" 508 else 509 checkresult $saverc 2 "$opt" 510 fi 511 done 512 fi 513 514 # Locale-specific tests, provided that either the "fr_FR", "fr_CA", "french" 515 # or "fr" locale is available. The first two are Unix-like standards; the 516 # last two are for Windows. Unfortunately, different versions of the French 517 # locale give different outputs for some items. This test passes if the 518 # output matches any one of the alternative output files. 519 520 if [ $do3 = yes ] ; then 521 locale= 522 523 # In some environments locales that are listed by the "locale -a" 524 # command do not seem to work with setlocale(). Therefore, we do 525 # a preliminary test to see if pcre2test can set one before going 526 # on to use it. 527 528 for loc in 'fr_FR' 'french' 'fr' 'fr_CA'; do 529 locale -a | grep "^$loc\$" >/dev/null 530 if [ $? -eq 0 ] ; then 531 echo "/a/locale=$loc" | \ 532 $sim $valgrind ./pcre2test -q $bmode | \ 533 grep "Failed to set locale" >/dev/null 534 if [ $? -ne 0 ] ; then 535 locale=$loc 536 if [ "$locale" = "fr_FR" ] ; then 537 infile=$testdata/testinput3 538 outfile=$testdata/testoutput3 539 outfile2=$testdata/testoutput3A 540 outfile3=$testdata/testoutput3B 541 else 542 infile=test3input 543 outfile=test3output 544 outfile2=test3outputA 545 outfile3=test3outputB 546 sed "s/fr_FR/$loc/" $testdata/testinput3 >test3input 547 sed "s/fr_FR/$loc/" $testdata/testoutput3 >test3output 548 sed "s/fr_FR/$loc/" $testdata/testoutput3A >test3outputA 549 sed "s/fr_FR/$loc/" $testdata/testoutput3B >test3outputB 550 fi 551 break 552 fi 553 fi 554 done 555 556 if [ "$locale" != "" ] ; then 557 echo $title3 "(using '$locale' locale)" 558 for opt in "" $jitopt; do 559 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $infile testtry 560 if [ $? = 0 ] ; then 561 case "$opt" in 562 -jit) with=" with JIT";; 563 *) with="";; 564 esac 565 if $cf $outfile testtry >teststdout || \ 566 $cf $outfile2 testtry >teststdout || \ 567 $cf $outfile3 testtry >teststdout 568 then 569 echo " OK$with" 570 else 571 echo "** Locale test did not run successfully$with. The output did not match" 572 echo " $outfile, $outfile2 or $outfile3." 573 echo " This may mean that there is a problem with the locale settings rather" 574 echo " than a bug in PCRE2." 575 exit 1 576 fi 577 else exit 1 578 fi 579 done 580 else 581 echo "Cannot test locale-specific features - none of the 'fr_FR', 'fr_CA'," 582 echo "'fr' or 'french' locales can be set, or the \"locale\" command is" 583 echo "not available to check for them." 584 echo " " 585 fi 586 fi 587 588 # Tests for UTF and Unicode property support 589 590 if [ $do4 = yes ] ; then 591 echo ${title4A}-${bits}${title4B} 592 if [ $utf -eq 0 ] ; then 593 echo " Skipped because UTF-$bits support is not available" 594 else 595 for opt in "" $jitopt; do 596 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput4 testtry 597 checkresult $? 4 "$opt" 598 done 599 fi 600 fi 601 602 if [ $do5 = yes ] ; then 603 echo ${title5A}-${bits}$title5B 604 if [ $utf -eq 0 ] ; then 605 echo " Skipped because UTF-$bits support is not available" 606 else 607 for opt in "" $jitopt; do 608 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput5 testtry 609 checkresult $? 5 "$opt" 610 done 611 fi 612 fi 613 614 # Tests for DFA matching support 615 616 if [ $do6 = yes ] ; then 617 echo $title6 618 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput6 testtry 619 checkresult $? 6 "" 620 fi 621 622 if [ $do7 = yes ] ; then 623 echo ${title7A}-${bits}$title7B 624 if [ $utf -eq 0 ] ; then 625 echo " Skipped because UTF-$bits support is not available" 626 else 627 $sim $valgrind ./pcre2test -q $setstack $bmode $opt $testdata/testinput7 testtry 628 checkresult $? 7 "" 629 fi 630 fi 631 632 # Test of internal offsets and code sizes. This test is run only when there 633 # is UTF/UCP support. The actual tests are mostly the same as in some of the 634 # above, but in this test we inspect some offsets and sizes. This is a 635 # doublecheck for the maintainer, just in case something changes unexpectely. 636 # The output from this test is different in 8-bit, 16-bit, and 32-bit modes 637 # and for different link sizes, so there are different output files for each 638 # mode and link size. 639 640 if [ $do8 = yes ] ; then 641 echo $title8 642 if [ $utf -eq 0 ] ; then 643 echo " Skipped because UTF-$bits support is not available" 644 else 645 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput8 testtry 646 checkresult $? 8-$bits-$link_size "" 647 fi 648 fi 649 650 # Tests for 8-bit-specific features 651 652 if [ "$do9" = yes ] ; then 653 echo $title9 654 if [ "$bits" = "16" -o "$bits" = "32" ] ; then 655 echo " Skipped when running 16/32-bit tests" 656 else 657 for opt in "" $jitopt; do 658 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput9 testtry 659 checkresult $? 9 "$opt" 660 done 661 fi 662 fi 663 664 # Tests for UTF-8 and UCP 8-bit-specific features 665 666 if [ "$do10" = yes ] ; then 667 echo $title10 668 if [ "$bits" = "16" -o "$bits" = "32" ] ; then 669 echo " Skipped when running 16/32-bit tests" 670 elif [ $utf -eq 0 ] ; then 671 echo " Skipped because UTF-$bits support is not available" 672 else 673 for opt in "" $jitopt; do 674 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput10 testtry 675 checkresult $? 10 "$opt" 676 done 677 fi 678 fi 679 680 # Tests for 16-bit and 32-bit features. Output is different for the two widths. 681 682 if [ $do11 = yes ] ; then 683 echo $title11 684 if [ "$bits" = "8" ] ; then 685 echo " Skipped when running 8-bit tests" 686 else 687 for opt in "" $jitopt; do 688 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput11 testtry 689 checkresult $? 11-$bits "$opt" 690 done 691 fi 692 fi 693 694 # Tests for 16-bit and 32-bit features with UTF-16/32 and UCP support. Output 695 # is different for the two widths. 696 697 if [ $do12 = yes ] ; then 698 echo $title12 699 if [ "$bits" = "8" ] ; then 700 echo " Skipped when running 8-bit tests" 701 elif [ $utf -eq 0 ] ; then 702 echo " Skipped because UTF-$bits support is not available" 703 else 704 for opt in "" $jitopt; do 705 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput12 testtry 706 checkresult $? 12-$bits "$opt" 707 done 708 fi 709 fi 710 711 # Tests for 16/32-bit-specific features in DFA non-UTF modes 712 713 if [ $do13 = yes ] ; then 714 echo $title13 715 if [ "$bits" = "8" ] ; then 716 echo " Skipped when running 8-bit tests" 717 else 718 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput13 testtry 719 checkresult $? 13 "" 720 fi 721 fi 722 723 # Tests for DFA UTF and UCP features. Output is different for the different widths. 724 725 if [ $do14 = yes ] ; then 726 echo $title14 727 if [ $utf -eq 0 ] ; then 728 echo " Skipped because UTF-$bits support is not available" 729 else 730 $sim $valgrind ./pcre2test -q $setstack $bmode $opt $testdata/testinput14 testtry 731 checkresult $? 14-$bits "" 732 fi 733 fi 734 735 # Test non-JIT match and recursion limits 736 737 if [ $do15 = yes ] ; then 738 echo $title15 739 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput15 testtry 740 checkresult $? 15 "" 741 fi 742 743 # Test JIT-specific features when JIT is not available 744 745 if [ $do16 = yes ] ; then 746 echo $title16 747 if [ $jit -ne 0 ] ; then 748 echo " Skipped because JIT is available" 749 else 750 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput16 testtry 751 checkresult $? 16 "" 752 fi 753 fi 754 755 # Test JIT-specific features when JIT is available 756 757 if [ $do17 = yes ] ; then 758 echo $title17 759 if [ $jit -eq 0 -o "$nojit" = "yes" ] ; then 760 echo " Skipped because JIT is not available or nojit was specified" 761 else 762 $sim $valgrind $vjs ./pcre2test -q $setstack $bmode $testdata/testinput17 testtry 763 checkresult $? 17 "" 764 fi 765 fi 766 767 # Tests for the POSIX interface without UTF/UCP (8-bit only) 768 769 if [ $do18 = yes ] ; then 770 echo $title18 771 if [ "$bits" = "16" -o "$bits" = "32" ] ; then 772 echo " Skipped when running 16/32-bit tests" 773 else 774 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput18 testtry 775 checkresult $? 18 "" 776 fi 777 fi 778 779 # Tests for the POSIX interface with UTF/UCP (8-bit only) 780 781 if [ $do19 = yes ] ; then 782 echo $title19 783 if [ "$bits" = "16" -o "$bits" = "32" ] ; then 784 echo " Skipped when running 16/32-bit tests" 785 elif [ $utf -eq 0 ] ; then 786 echo " Skipped because UTF-$bits support is not available" 787 else 788 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput19 testtry 789 checkresult $? 19 "" 790 fi 791 fi 792 793 # Serialization tests 794 795 if [ $do20 = yes ] ; then 796 echo $title20 797 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput20 testtry 798 checkresult $? 20 "" 799 fi 800 801 # \C tests without UTF - DFA matching is supported 802 803 if [ "$do21" = yes ] ; then 804 echo $title21 805 if [ $supportBSC -eq 0 ] ; then 806 echo " Skipped because \C is disabled" 807 else 808 for opt in "" $jitopt -dfa; do 809 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput21 testtry 810 checkresult $? 21 "$opt" 811 done 812 fi 813 fi 814 815 # \C tests with UTF - DFA matching is not supported for \C in UTF mode 816 817 if [ "$do22" = yes ] ; then 818 echo $title22 819 if [ $supportBSC -eq 0 ] ; then 820 echo " Skipped because \C is disabled" 821 elif [ $utf -eq 0 ] ; then 822 echo " Skipped because UTF-$bits support is not available" 823 else 824 for opt in "" $jitopt; do 825 $sim $valgrind ${opt:+$vjs} ./pcre2test -q $setstack $bmode $opt $testdata/testinput22 testtry 826 checkresult $? 22-$bits "$opt" 827 done 828 fi 829 fi 830 831 # Test when \C is disabled 832 833 if [ "$do23" = yes ] ; then 834 echo $title23 835 if [ $supportBSC -ne 0 ] ; then 836 echo " Skipped because \C is not disabled" 837 else 838 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput23 testtry 839 checkresult $? 23 "" 840 fi 841 fi 842 843 # Non-UTF pattern conversion tests 844 845 if [ "$do24" = yes ] ; then 846 echo $title24 847 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput24 testtry 848 checkresult $? 24 "" 849 fi 850 851 # UTF pattern conversion tests 852 853 if [ "$do25" = yes ] ; then 854 echo $title25 855 if [ $utf -eq 0 ] ; then 856 echo " Skipped because UTF-$bits support is not available" 857 else 858 $sim $valgrind ./pcre2test -q $setstack $bmode $testdata/testinput25 testtry 859 checkresult $? 25 "" 860 fi 861 fi 862 863# End of loop for 8/16/32-bit tests 864done 865 866# Clean up local working files 867rm -f testbtables testSinput test3input testsaved1 testsaved2 test3output test3outputA test3outputB teststdout teststderr testtry 868 869# End 870