[Flang] Port test_folding.sh to Python

[ijan1]

Summary

To enable Flang testing on Windows,
shells scripts have to be ported to Python.
The following changes have been made:
Ported test_folding.sh to Python;
Additional changes to the tests themselves
to use the new script.

LIBPGMATH support for testing
not available at this point.

[ijan1]

"folding21.f90" was added a few days ago and fails in all cases. It's not been set as "XFAIL" so I am unsure if that's something on my end.

[ijan1]

Hopefully fixes the few failing tests due to a regex issue.

[Meinersbur]

flang/test/Evaluate/test_folding.py

67

cf folding05.f90:
Consider specifying encoding="utf-8". Docs mention that the default-encoding is platform-dependent and it seems to be UTF-8 on Linux but cp1252 (Maybe dependent on localization) on Windows.

[ijan1]

Specified encoding to fix a failing test on Windows.

[ijan1]

@Meinersbur would it be fine to also disable these failings tests on Windows? I have filed a bug report on bugzilla[1] for D107956. I could include them there or file a new one.

[1] https://bugs.llvm.org/show_bug.cgi?id=51597

[ijan1]

Rebased to include newly added tests.

[ijan1]

Re-enabling some tests.

[ijan1]

Rebase to mollify buildbots.

[ijan1]

@Meinersbur is this one ready to be merged?

[Meinersbur]

LGTM

Please edit the commit messsage (remove Known test failures) before landing.

flang/test/Evaluate/folding01.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 
 ! Test intrinsic operation folding
 
 module m
 ! Check logical intrinsic operation folding
   logical, parameter :: test_not1 = .NOT..false.
   logical, parameter :: test_not2 = .NOT..NOT..true.
 

flang/test/Evaluate/folding02.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
+
 ! Check intrinsic function folding with host runtime library
 
 module m
   real(2), parameter :: eps2 = 0.001_2
   real(2), parameter :: eps3 = 0.001_3
   real(4), parameter :: eps4 = 0.000001_4
   real(8), parameter :: eps8 = 0.000000000000001_8
 

flang/test/Evaluate/folding03.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test operation folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) and integer(4) extrema.
 
 #define TEST_ISNAN(v) logical, parameter :: test_##v =.NOT.(v.EQ.v)
 
 module integer_tests
   integer(4), parameter :: i4_pmax = 2147483647_4
   ! Fortran grammar rule R605 prevents from writing -2147483648_4 in an

flang/test/Evaluate/folding04.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test intrinsic function folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) extrema.
 
 #define TEST_ISNAN(v) logical, parameter :: test_##v =.NOT.(v.EQ.v)
 
 
 module real_tests
   ! Test real(4) intrinsic folding on edge cases (inf and NaN)

flang/test/Evaluate/folding06.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test transformational intrinsic function folding
 
 module m
 
   ! Testing ASSOCATED
   integer, pointer :: int_pointer
   integer, allocatable :: int_allocatable
   logical, parameter :: test_Assoc1 = .not.(associated(null()))

flang/test/Evaluate/folding07.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test numeric model inquiry intrinsics
 
 module m
 
   integer, parameter :: &
     bs1 = bit_size(0_1), &
     bs2 = bit_size(0_2), &
     bs4 = bit_size(0_4), &

flang/test/Evaluate/folding08.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of LBOUND and UBOUND
 
 module m
  contains
   function foo()
     real :: foo(2:3,4:6)
   end function
   subroutine test(n1,a1,a2)

flang/test/Evaluate/folding09.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of IS_CONTIGUOUS on simply contiguous items (9.5.4)
 ! When IS_CONTIGUOUS() is constant, it's .TRUE.
 
 module m
   real, target :: hosted(2)
  contains
   function f()
     real, pointer, contiguous :: f(:)

flang/test/Evaluate/folding10.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of SHAPE(TRANSFER(...))
 
 module m
   logical, parameter :: test_size_1 = size(shape(transfer(123456789,0_1,size=4))) == 1
   logical, parameter :: test_size_2 = all(shape(transfer(123456789,0_1,size=4)) == [4])
   logical, parameter :: test_scalar_1 = size(shape(transfer(123456789, 0_1))) == 0
   logical, parameter :: test_vector_1 = size(shape(transfer(123456789, [0_1]))) == 1
   logical, parameter :: test_vector_2 = all(shape(transfer(123456789, [0_1])) == [4])
   logical, parameter :: test_array_1 = size(shape(transfer(123456789, reshape([0_1],[1,1])))) == 1
   logical, parameter :: test_array_2 = all(shape(transfer(123456789, reshape([0_1],[1,1]))) == [4])
   logical, parameter :: test_array_3 = all(shape(transfer([1.,2.,3.], [(0.,0.)])) == [2])
 end module

flang/test/Evaluate/folding11.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 module m
   complex, parameter :: z1 = 1. + (2., 3.)
   logical, parameter :: test_z1 = z1 == (3., 3.)
   complex, parameter :: z2 = 1 + (2., 3.)
   logical, parameter :: test_z2 = z2 == (3., 3.)
   complex, parameter :: z3 = 2. * (3., 4.)
   logical, parameter :: test_z3 = z3 == (6., 8.)
   complex, parameter :: z4 = 2 * (3., 4.)

flang/test/Evaluate/folding12.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of structure constructors
 module m1
   type parent_type
     integer :: parent_field
   end type parent_type
   type, extends(parent_type) :: child_type
     integer :: child_field 
   end type child_type

flang/test/Evaluate/folding13.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of array constructors with constant implied DO bounds;
 ! their indices are constant expressions and can be used as such.
 module m1
   integer, parameter :: kinds(*) = [1, 2, 4, 8]
   integer(kind=8), parameter :: clipping(*) = [integer(kind=8) :: &
     (int(z'100010101', kind=kinds(j)), j=1,4)]
   integer(kind=8), parameter :: expected(*) = [ &
     int(z'01',8), int(z'0101',8), int(z'00010101',8), int(z'100010101',8)]
   logical, parameter :: test_clipping = all(clipping == expected)
 end module

flang/test/Evaluate/folding14.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of isnan() extension
 module m1
   logical, parameter :: results(*) = isnan([ &
     0., &
     -0., &
 !WARN: division by zero
     1./0., &
 !WARN: invalid argument on division

flang/test/Evaluate/folding15.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test folding of array constructors with duplicate names for the implied
 ! DO variables
 module m1
   integer, parameter :: expected(12) = [1, 2, 4, 6, 1, 2, 4, 6, 1, 2, 3, 6]
   integer, parameter :: dups(12) = &
     [ ((iDuplicate, iDuplicate = 1,j), &
        (2 * iDuplicate, iDuplicate = j,3 ), &
         j = 1,3 ) ]
   logical, parameter :: test_dups = all(dups == expected)
 end module

flang/test/Evaluate/folding16.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Ensure that lower bounds are accounted for in intrinsic folding;
 ! this is a regression test for a bug in which they were not
 module m
   real, parameter :: a(-1:-1) = 1.
   real, parameter :: b(-1:-1) = log(a)
   integer, parameter :: c(-1:1) = [33, 22, 11]
   integer, parameter :: d(1:3) = [33, 22, 11]
   integer, parameter :: e(-2:0) = ([33, 22, 11])
   logical, parameter :: test_1 = lbound((a),1)==-1 .and. lbound(b,1)==-1 .and. &
                                lbound(log(a),1)==1 .and. all(b==0)
   logical, parameter :: test_2 = all(c .eq. d)
   logical, parameter :: test_3 = all(c .eq. e)
   logical, parameter :: test_4 = all(d .eq. e)
 end

flang/test/Evaluate/folding17.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test implementations of STORAGE_SIZE() and SIZEOF() as expression rewrites
 module m1
   type :: t1
     real :: a(2,3)
     character*5 :: c(3)
   end type
   type :: t2(k)
     integer, kind :: k

flang/test/Evaluate/folding18.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Test implementations of IEEE inquiry functions
 module m
   use ieee_arithmetic
   logical, parameter :: test_ieee_support_datatype = ieee_support_datatype() &
     .and. ieee_support_datatype(1.0_2) &
     .and. ieee_support_datatype(1.0_3) &
     .and. ieee_support_datatype(1.0_4) &
     .and. ieee_support_datatype(1.0_8) &

flang/test/Evaluate/folding20.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests reduction intrinsic function folding
 module m
   implicit none
   integer, parameter :: intmatrix(*,*) = reshape([1, 2, 3, 4, 5, 6], [2, 3])
   logical, parameter :: odds(2,3) = mod(intmatrix, 2) == 1
   character(*), parameter :: chmatrix(*,*) = reshape(['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr'], [2, 3])
 
   logical, parameter :: test_allidentity = all([Logical::])

flang/test/Evaluate/folding21.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Check array sizes with varying extents, including extents where the upper
 ! bound is less than the lower bound
 module m
  contains
   subroutine s1(a,b)
     real nada1(-2:-1)    ! size =  2
     real nada2(-1:-1)    ! size =  1
     real nada3( 0:-1)    ! size =  0

flang/test/Evaluate/folding22.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 
 ! Test character concatenation folding
 
 logical, parameter :: test_scalar_scalar =  ('ab' // 'cde').eq.('abcde')
 
 character(2), parameter :: scalar_array(2) =  ['1','2'] // 'a'
 logical, parameter :: test_scalar_array = all(scalar_array.eq.(['1a', '2a']))
 

flang/test/Evaluate/folding23.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of EOSHIFT (valid cases)
 module m
   integer, parameter :: arr(2,3) = reshape([1, 2, 3, 4, 5, 6], shape(arr))
   logical, parameter :: test_sanity = all([arr] == [1, 2, 3, 4, 5, 6])
   logical, parameter :: test_eoshift_0 = all(eoshift([1, 2, 3], 0) == [1, 2, 3])
   logical, parameter :: test_eoshift_1 = all(eoshift([1, 2, 3], 1) == [2, 3, 0])
   logical, parameter :: test_eoshift_2 = all(eoshift([1, 2, 3], -1) == [0, 1, 2])
   logical, parameter :: test_eoshift_3 = all(eoshift([1., 2., 3.], 1) == [2., 3., 0.])
   logical, parameter :: test_eoshift_4 = all(eoshift(['ab', 'cd', 'ef'], -1, 'x') == ['x ', 'ab', 'cd'])
   logical, parameter :: test_eoshift_5 = all([eoshift(arr, 1, dim=1)] == [2, 0, 4, 0, 6, 0])
   logical, parameter :: test_eoshift_6 = all([eoshift(arr, 1, dim=2)] == [3, 5, 0, 4, 6, 0])
   logical, parameter :: test_eoshift_7 = all([eoshift(arr, [1, -1, 0])] == [2, 0, 0, 3, 5, 6])
   logical, parameter :: test_eoshift_8 = all([eoshift(arr, [1, -1], dim=2)] == [3, 5, 0, 0, 2, 4])
 end module

flang/test/Evaluate/folding24.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of PACK (valid cases)
 module m
   integer, parameter :: arr(2,3) = reshape([1, 2, 3, 4, 5, 6], shape(arr))
   logical, parameter :: odds(*,*) = modulo(arr, 2) /= 0
   integer, parameter :: vect(*) = [(j, j=-10, -1)]
   logical, parameter :: test_pack_1 = all(pack(arr, .true.) == [arr])
   logical, parameter :: test_pack_2 = all(pack(arr, .false.) == [integer::])
   logical, parameter :: test_pack_3 = all(pack(arr, odds) == [1, 3, 5])
   logical, parameter :: test_pack_4 = all(pack(arr, .not. odds) == [2, 4, 6])
   logical, parameter :: test_pack_5 = all(pack(arr, .true., vect) == [1, 2, 3, 4, 5, 6, -4, -3, -2, -1])
   logical, parameter :: test_pack_6 = all(pack(arr, .false., vect) == vect)
   logical, parameter :: test_pack_7 = all(pack(arr, odds, vect) == [1, 3, 5, -7, -6, -5, -4, -3, -2, -1])
   logical, parameter :: test_pack_8 = all(pack(arr, .not. odds, vect) == [2, 4, 6, -7, -6, -5, -4, -3, -2, -1])
 end module

flang/test/Evaluate/folding25.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of UNPACK (valid cases)
 module m
   integer, parameter :: vector(*) = [1, 2, 3, 4]
   integer, parameter :: field(2,3) = reshape([(-j,j=1,6)], shape(field))
   logical, parameter :: mask(*,*) = reshape([.false., .true., .true., .false., .false., .true.], shape(field))
   logical, parameter :: test_unpack_1 = all(unpack(vector, mask, 0) == reshape([0,1,2,0,0,3], shape(mask)))
   logical, parameter :: test_unpack_2 = all(unpack(vector, mask, field) == reshape([-1,1,2,-4,-5,3], shape(mask)))
 end module

flang/test/Evaluate/folding26.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of TRANSPOSE
 module m
   integer, parameter :: matrix(0:1,0:2) = reshape([1,2,3,4,5,6],shape(matrix))
   logical, parameter :: test_transpose_1 = all(transpose(matrix) == reshape([1,3,5,2,4,6],[3,2]))
 end module

flang/test/Evaluate/folding27.f90

-! RUN: %S/test_folding.sh %s %t %flang_fc1
-! REQUIRES: shell
+! RUN: %python %S/test_folding.py %s %flang_fc1
 ! Tests folding of CSHIFT (valid cases)
 module m
   integer, parameter :: arr(2,3) = reshape([1, 2, 3, 4, 5, 6], shape(arr))
   logical, parameter :: test_sanity = all([arr] == [1, 2, 3, 4, 5, 6])
   logical, parameter :: test_cshift_0 = all(cshift([1, 2, 3], 0) == [1, 2, 3])
   logical, parameter :: test_cshift_1 = all(cshift([1, 2, 3], 1) == [2, 3, 1])
   logical, parameter :: test_cshift_2 = all(cshift([1, 2, 3], 3) == [1, 2, 3])
   logical, parameter :: test_cshift_3 = all(cshift([1, 2, 3], 4) == [2, 3, 1])
   logical, parameter :: test_cshift_4 = all(cshift([1, 2, 3], -1) == [3, 1, 2])
   logical, parameter :: test_cshift_5 = all([cshift(arr, 1, dim=1)] == [2, 1, 4, 3, 6, 5])
   logical, parameter :: test_cshift_6 = all([cshift(arr, 1, dim=2)] == [3, 5, 1, 4, 6, 2])
   logical, parameter :: test_cshift_7 = all([cshift(arr, [1, 2, 3])] == [2, 1, 3, 4, 6, 5])
   logical, parameter :: test_cshift_8 = all([cshift(arr, [1, 2], dim=2)] == [3, 5, 1, 6, 2, 4])
 end module

flang/test/Evaluate/test_folding.py

+#!/usr/bin/env python3
+
+"""This script verifies expression folding.
+It compiles a source file with '-fdebug-dump-symbols'
+and looks for parameter declarations to check
+they have been folded as expected.
+To check folding of an expression EXPR,
+the fortran program passed to this script
+must contain the following:
+
+  logical, parameter :: test_x = <compare EXPR to expected value>
+
+This script will test that all parameter
+with a name starting with "test_"
+have been folded to .true.
+For instance, acos folding can be tested with:
+
+  real(4), parameter :: res_acos = acos(0.5_4)
+  real(4), parameter :: exp_acos = 1.047
+  logical, parameter :: test_acos = abs(res_acos - exp_acos).LE.(0.001_4)
+
+There are two kinds of failure:
+  - test_x is folded to .false..
+    This means the expression was folded
+    but the value is not as expected.
+  - test_x is not folded (it is neither .true. nor .false.).
+    This means the compiler could not fold the expression.
+
+Parameters:
+    sys.argv[1]: a source file with contains the input and expected output
+    sys.argv[2]: the Flang frontend driver
+    sys.argv[3:]: Optional arguments to the Flang frontend driver"""
+
+import os
+import sys
+import tempfile
+import re
+import subprocess
+
+from difflib import unified_diff
+from pathlib import Path
+
+def check_args(args):
+    """Verifies that the number is arguments passed is correct."""
+    if len(args) < 3:
+        print(f"Usage: {args[0]} <fortran-source> <flang-command>")
+        sys.exit(1)
+
+def set_source(source):
+    """Sets the path to the source files."""
+    if not Path(source).is_file():
+        print(f"File not found: {src}")
+        sys.exit(1)
+    return Path(source)
+
+def set_executable(exe):
+    """Sets the path to the Flang frontend driver."""
+    if not Path(exe).is_file():
+        print(f"Flang was not found: {exe}")
+        sys.exit(1)
+    return str(Path(exe))
+
+check_args(sys.argv)
+cwd = os.getcwd()
+srcdir = set_source(sys.argv[1]).resolve()
+with open(srcdir, 'r', encoding="utf-8") as f:
+    src = f.readlines()
+src1 = ""
+src2 = ""
+src3 = ""
+src4 = ""
+messages = ""
+actual_warnings = ""
+expected_warnings = ""
+warning_diffs = ""
+
+flang_fc1 = set_executable(sys.argv[2])
+flang_fc1_args = sys.argv[3:]
+flang_fc1_options = ""
+LIBPGMATH = os.getenv('LIBPGMATH')
+if LIBPGMATH:
+    flang_fc1_options = ["-fdebug-dump-symbols", "-DTEST_LIBPGMATH"]
+    print("Assuming libpgmath support")
+else:
+    flang_fc1_options = ["-fdebug-dump-symbols"]
+    print("Not assuming libpgmath support")
+
+cmd = [flang_fc1, *flang_fc1_args, *flang_fc1_options, str(srcdir)]
+with tempfile.TemporaryDirectory() as tmpdir:
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                          check=True, universal_newlines=True, cwd=tmpdir)
+    src1 = proc.stdout
+    messages = proc.stderr
+
+for line in src1.split("\n"):
+    m = re.search(r"(\w*)(?=, PARAMETER).*init:(.*)", line)
+    if m:
+        src2 += f"{m.group(1)} {m.group(2)}\n"
+
+for line in src2.split("\n"):
+    m = re.match(r"test_*", line)
+    if m:
+        src3 += f"{m.string}\n"
+
+for passed_results, line in enumerate(src3.split("\n")):
+    m = re.search(r"\.false\._.$", line)
+    if m:
+        src4 += f"{line}\n"
+
+for line in messages.split("\n"):
+    m = re.search(r"[^:]*:(\d*):\d*: (.*)", line)
+    if m:
+        actual_warnings += f"{m.group(1)}: {m.group(2)}\n"
+
+passed_warnings = 0
+warnings = []
+for i, line in enumerate(src, 1):
+    m = re.search(r"(?:!WARN:)(.*)", line)
+    if m:
+        warnings.append(m.group(1))
+        continue
+    if warnings:
+        for x in warnings:
+            passed_warnings += 1
+            expected_warnings += f"{i}:{x}\n"
+        warnings = []
+
+for line in unified_diff(actual_warnings.split("\n"),
+                         expected_warnings.split("\n"), n=0):
+    line = re.sub(r"(^\-)(\d+:)", r"\nactual at \g<2>", line)
+    line = re.sub(r"(^\+)(\d+:)", r"\nexpect at \g<2>", line)
+    warning_diffs += line
+
+if src4 or warning_diffs:
+    print("Folding test failed:")
+    # Prints failed tests, including parameters with the same
+    # suffix so that more information can be obtained by declaring
+    # expected_x and result_x
+    if src4:
+        for line in src4.split("\n"):
+            m = re.match(r"test_(\w+)", line)
+            if m:
+                for line in src2.split("\n"):
+                    if m.group(1) in line:
+                        print(line)
+    if warning_diffs:
+        print(warning_diffs)
+    print()
+    print("FAIL")
+    sys.exit(1)
+else:
+    print()
+    print(f"All {passed_results+passed_warnings} tests passed")
+    print("PASS")
+

flang/test/Evaluate/test_folding.sh

-#!/usr/bin/env bash
-# This script verifies expression folding.
-# It compiles a source file with '-fdebug-dump-symbols' and looks for
-# parameter declarations to check they have been folded as expected.
-# To check folding of an expression EXPR, the fortran program passed to this script
-# must contain the following:
-#   logical, parameter :: test_x = <compare EXPR to expected value>
-# This script will test that all parameter with a name starting with "test_"
-# have been folded to .true.
-# For instance, acos folding can be tested with:
-#
-#   real(4), parameter :: res_acos = acos(0.5_4)
-#   real(4), parameter :: exp_acos = 1.047
-#   logical, parameter :: test_acos = abs(res_acos - exp_acos).LE.(0.001_4)
-#
-# There are two kinds of failure:
-#   - test_x is folded to .false.. This means the expression was folded
-#     but the value is not as expected.
-#   - test_x is not folded (it is neither .true. nor .false.). This means the
-#     compiler could not fold the expression.
-
-if [[ $# < 3 ]]; then
-  echo "Usage: $0 <fortran-source> <temp test dir> <f18-executable>"
-  exit 1
-fi
-
-src=$1
-[[ ! -f $src ]] && echo "File not found: $src" && exit 1
-shift
-
-temp=$1
-mkdir -p $temp
-shift
-
-CMD="$* -fdebug-dump-symbols"
-
-# Check if tests should assume folding is using libpgmath
-if [[ $LIBPGMATH ]]; then
-  CMD="$CMD -DTEST_LIBPGMATH"
-  echo "Assuming libpgmath support"
-else
-  echo "Not assuming libpgmath support"
-fi
-
-src1=$temp/symbols.log
-src2=$temp/all_parameters.log
-src3=$temp/tested_parameters.log
-src4=$temp/failures.log
-messages=$temp/messages.log
-actual_warnings=$temp/actwarnings.log
-expected_warnings=$temp/expwarnings.log
-warning_diffs=$temp/warnings.diff
-
-if ! ( cd $temp; $CMD $src ) > $src1 2> $messages # compile, dumping symbols
-then
-  cat $messages
-  echo FAIL compilation
-  exit 1
-fi
-
-# Get all PARAMETER declarations
-sed -e '/, PARAMETER/!d' -e 's/, PARAMETER.*init:/ /' \
-   -e 's/^ *//'  $src1 > $src2
-
-# Collect test results
-sed -e '/^test_/!d' $src2 > $src3
-
-# Check all tests results (keep tests that do not resolve to true)
-sed -e '/\.true\._.$/d' $src3 > $src4
-
-
-#Check warnings
-sed -n 's=^[^:]*:\([0-9]*\):[0-9]*: =\1: =p' $messages > $actual_warnings
-
-awk '
-  BEGIN { FS = "!WARN: "; }
-  /^ *!WARN: / { warnings[nwarnings++] = $2; next; }
-  { for (i = 0; i < nwarnings; ++i) printf "%d: %s\n", NR, warnings[i]; nwarnings = 0; }
-' $src > $expected_warnings
-
-diff -U0 $actual_warnings $expected_warnings > $warning_diffs
-
-if [ -s $src4 ] || [ -s $warning_diffs ]; then
-  echo "folding test failed:"
-  # Print failed tests (It will actually print all parameters
-  # that have the same suffix as the failed test so that one can get more info
-  # by declaring expected_x and result_x for instance)
-  if [[ -s $src4 ]]; then
-    sed -e 's/test_/_/' -e 's/ .*//' $src4 | grep -f - $src2
-  fi
-  if [[ -s $warning_diffs ]]; then
-    echo "$cmd"
-    < $warning_diffs \
-      sed -n -e 's/^-\([0-9]\)/actual at \1/p' -e 's/^+\([0-9]\)/expect at \1/p' \
-      | sort -n -k 2
-  fi
-  echo FAIL
-  exit 1
-else
-  passed_results=$(wc -l < $src3)
-  passed_warnings=$(wc -l < $expected_warnings)
-  passed=$(($passed_warnings + $passed_results))
-  echo all $passed tests passed
-  echo PASS
-fi