Merge branch 'feature/ini-options' into 'master'

Feature/ini options

* Read formcompiler options from ini files
* Have a systemtest macros allowing variation in formcompiler arguments
* Rewrite the test suite using it

Exhibits some more problems in our test suite.

This fixes #1.

See merge request !20

cmake/modules/DunePerftoolMacros.cmake

@@ -115,3 +115,5 @@ function(add_generated_executable)
 
   add_dependencies(generation ${GEN_TARGET})
 endfunction()
+
+include(GeneratedSystemtests)
\ No newline at end of file

cmake/modules/GeneratedSystemtests.cmake

+# System testing for generated executables. All ideas taken from dune-testtools.
+#
+
+function(dune_add_formcompiler_system_test)
+  # parse arguments
+  set(OPTION DEBUG)
+  set(SINGLE INIFILE BASENAME SCRIPT UFLFILE)
+  set(MULTI CREATED_TARGETS)
+  cmake_parse_arguments(SYSTEMTEST "${OPTION}" "${SINGLE}" "${MULTI}" ${ARGN})
+
+  if(SYSTEMTEST_UNPARSED_ARGUMENTS)
+    message(WARNING "dune_add_system_test: Encountered unparsed arguments: This often indicates typos in named arguments")
+  endif()
+
+  # construct a string containg DEBUG to pass the debug flag to the other macros
+  set(DEBUG "")
+  if(SYSTEMTEST_DEBUG)
+    set(DEBUG "DEBUG")
+  endif()
+
+  # set a default for the script. call_executable.py just calls the executable.
+  # There, it is also possible to hook in things depending on the inifile
+  if(NOT SYSTEMTEST_SCRIPT)
+    set(SYSTEMTEST_SCRIPT dune_execute.py)
+  endif()
+
+  # we provide two signatures: either a source(s) is given or a target(s)
+  if(NOT SYSTEMTEST_UFLFILE)
+    message(FATAL_ERROR "UFLFILE must be given for dune_add_generated_system_test!")
+  endif()
+
+  # Configure a bogus file from the meta ini file. This is a trick to retrigger configuration on meta ini changes.
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/${SYSTEMTEST_INIFILE} ${CMAKE_CURRENT_BINARY_DIR}/tmp_${SYSTEMTEST_INIFILE})
+
+  # expand the given meta ini file into the build tree
+  execute_process(COMMAND ${CMAKE_BINARY_DIR}/dune-env dune_expand_metaini.py --cmake --ini ${CMAKE_CURRENT_SOURCE_DIR}/${SYSTEMTEST_INIFILE} --dir ${CMAKE_CURRENT_BINARY_DIR} --section formcompiler
+                  OUTPUT_VARIABLE output)
+  parse_python_data(PREFIX INIINFO INPUT "${output}")
+
+  foreach(inifile ${INIINFO_names})
+    if(${INIINFO_${inifile}_suffix} STREQUAL "__empty")
+      set(tname ${SYSTEMTEST_BASENAME})
+    else()
+      set(tname ${SYSTEMTEST_BASENAME}_${INIINFO_${inifile}_suffix})
+      if(NOT TARGET ${SYSTEMTEST_BASENAME})
+        add_custom_target(${SYSTEMTEST_BASENAME})
+      endif()
+    endif()
+
+    add_generated_executable(TARGET ${tname}
+                             UFLFILE ${SYSTEMTEST_UFLFILE}
+                             FORM_COMPILER_ARGS --ini-file ${inifile}
+                             )
+
+    # Exclude the target from all
+    set_property(TARGET ${tname} PROPERTY EXCLUDE_FROM_ALL 1)
+
+    # Add dependency on the metatarget for this systemtest
+    if(NOT ${INIINFO_${inifile}_suffix} STREQUAL "__empty")
+      add_dependencies(${SYSTEMTEST_BASENAME} ${tname})
+    endif()
+
+    # and have it depend on the metatarget build_tests
+    add_dependencies(build_tests ${tname})
+
+    _add_test(NAME ${tname}
+              COMMAND ${CMAKE_BINARY_DIR}/dune-env ${SYSTEMTEST_SCRIPT}
+                    --exec ${tname}
+                    --ini "${CMAKE_CURRENT_BINARY_DIR}/${inifile}"
+                    --source ${CMAKE_CURRENT_SOURCE_DIR}
+              )
+
+    set_tests_properties(${tname} PROPERTIES SKIP_RETURN_CODE 77)
+    set_tests_properties(${tname} PROPERTIES TIMEOUT 20)
+  endforeach()
+endfunction()
\ No newline at end of file

python/dune/perftool/options.py

@@ -33,12 +33,7 @@ def get_form_compiler_arguments():
     parser.add_argument("--print-transformations", action="store_true", help="print out dot files after ufl tree transformations")
     parser.add_argument("--print-transformations-dir", type=str, help="place where to put dot files (can be omitted)")
     parser.add_argument("--diagonal-transformation-matrix", action="store_true", help="set option if the jacoby of the transformation is diagonal (axiparallel grids)")
-
-    # These are the options that I deemed necessary in uflpdelab
-#     parser.add_argument("--param-class-file", type=str, help="The filename for the generated parameter class header")
-#     parser.add_argument("--export-trafo-graphs", action="store_true", help="export expression graphs after the application of each single transformation")
-#     parser.add_argument("--parameter-tree", action="store_true", help="have the generated local operate take a Dune::ParameterTree as constructor argument")
-#     parser.add_argument("--inifile", type=str, help="The inifile that this program's driver should be hardcoded to. Omit to use a commandline argument ini file")
+    parser.add_argument("--ini-file", type=str, help="An inifile to use. A generated driver will be hard-coded to it, a [formcompiler] section will be used as default values to form compiler arguments (use snake case)")
 
     # Modify the positional argument to not be a list
     args = vars(parser.parse_args())
@@ -52,6 +47,8 @@ def get_form_compiler_arguments():
         args["driver_file"] = os.path.abspath(args["driver_file"])
     if args["operator_file"]:
         args["operator_file"] = os.path.abspath(args["operator_file"])
+    if args["ini_file"]:
+        args["ini_file"] = os.path.abspath(args["ini_file"])
 
     # Return the argument dict. This result is memoized to turn all get_option calls into simple dict lookups.
     return args
@@ -68,6 +65,20 @@ def init_option_dict():
         _option_dict.update(get_form_compiler_arguments())
         _arguments_read = True
 
+        # Read arguments from the given inifile
+        if _option_dict["ini_file"]:
+            from dune.common.parametertree.parser import parse_ini_file
+            inifile = parse_ini_file(_option_dict["ini_file"])
+            for key, value in inifile.get("formcompiler", {}).items():
+                if key not in _option_dict or _option_dict[key] is None:
+                    _option_dict[key] = value
+                elif not _option_dict[key]:
+                    # As `bool("0")` is True, we need to eval bools
+                    if isinstance(_option_dict[key], bool):
+                        _option_dict[key] = eval(value)
+                    else:
+                        _option_dict[key] = type(_option_dict[key])(value)
+
 
 def set_option(key, value):
     """Add the key value pair to the options.

test/heatequation/CMakeLists.txt

-#============
-# CG implicit
-#============
-
-add_generated_executable(UFLFILE heatequation.ufl
-                         TARGET heatequation_implicit
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-l2errorsquared 1e-7
-                         )
-
-
-dune_add_system_test(TARGET heatequation_implicit
-                     INIFILE heatequation_implicit.mini
-                     )
-
-#============
-# CG explicit
-#============
-
-add_generated_executable(UFLFILE heatequation.ufl
-                         TARGET heatequation_explicit
-                         FORM_COMPILER_ARGS --explicit-time-stepping --exact-solution-expression g --compare-l2errorsquared 1e-7
-                         )
-
-
-dune_add_system_test(TARGET heatequation_explicit
-                     INIFILE heatequation_explicit.mini
-                     )
-
-#============
-# DG implicit
-#============
-
-add_generated_executable(UFLFILE heatequation_dg.ufl
-                         TARGET heatequation_dg_implicit
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-l2errorsquared 1e-5
-                         )
-
-
-dune_add_system_test(TARGET heatequation_dg_implicit
-                     INIFILE heatequation_dg_implicit.mini
-                     )
-
-#============
-# DG explicit
-#============
-
-add_generated_executable(UFLFILE heatequation_dg.ufl
-                         TARGET heatequation_dg_explicit
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-l2errorsquared 1e-5
-                         )
-
-
-dune_add_system_test(TARGET heatequation_dg_explicit
-                     INIFILE heatequation_dg_explicit.mini
-                     )
-
+#=====
+# CG
+#=====
+
+dune_add_formcompiler_system_test(UFLFILE heatequation.ufl
+                                  BASENAME heatequation
+                                  INIFILE heatequation.mini
+                                  )
+
+#=====
+# DG
+#=====
+
+dune_add_formcompiler_system_test(UFLFILE heatequation_dg.ufl
+                                  BASENAME heatequation_dg
+                                  INIFILE heatequation_dg.mini
+                                  )
+
+#====================
+# Reference solutions
+#====================
 
 # Hand written reference solutions
 add_executable(heatequation_implicit_ref heatequation_implicit_ref.cc)

test/heatequation/heatequation_dg_explicit.mini → test/heatequation/heatequation.mini

-__name = heatequation_dg_explicit
+__name = heatequation_{__exec_suffix}
+__exec_suffix = implicit, explicit | expand scheme
 
 lowerleft = 0.0 0.0
 upperright = 1.0 1.0
@@ -9,3 +10,8 @@ elementType = simplical
 name = {__name}
 reference = heatequation_ref
 extension = vtu
+
+[formcompiler]
+explicit_time_stepping = 0, 1 | expand scheme
+exact_solution_expression = g
+compare_l2errorsquared = 1e-7

test/heatequation/heatequation_dg_implicit.mini → test/heatequation/heatequation_dg.mini

-__name = heatequation_dg_implicit
+__name = heatequation_dg_{__exec_suffix}
+__exec_suffix = implicit, explicit | expand scheme
 
 lowerleft = 0.0 0.0
 upperright = 1.0 1.0
@@ -9,3 +10,8 @@ elementType = simplical
 name = {__name}
 reference = heatequation_ref
 extension = vtu
+
+[formcompiler]
+explicit_time_stepping = 0, 1 | expand scheme
+exact_solution_expression = g
+compare_l2errorsquared = 1e-5

test/heatequation/heatequation_explicit.mini

-__name = heatequation_explicit
-
-lowerleft = 0.0 0.0
-upperright = 1.0 1.0
-elements = 8 8
-elementType = simplical
-
-[wrapper.vtkcompare]
-name = {__name}
-reference = heatequation_ref
-extension = vtu
-
-[instat]
-T = 1.0
-dt = 0.01
\ No newline at end of file

test/heatequation/heatequation_implicit.mini

-__name = heatequation_implicit
-
-lowerleft = 0.0 0.0
-upperright = 1.0 1.0
-elements = 32 32
-elementType = simplical
-
-[wrapper.vtkcompare]
-name = {__name}
-reference = heatequation_ref
-extension = vtu

test/laplace/CMakeLists.txt

-add_generated_executable(UFLFILE laplace.ufl
-                         TARGET laplace_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
+dune_add_formcompiler_system_test(UFLFILE laplace.ufl
+                                  BASENAME laplace
+                                  INIFILE laplace.mini)
 
-dune_add_system_test(TARGET laplace_numdiff
-                     INIFILE laplace_numdiff.mini)
-
-
-add_generated_executable(UFLFILE laplace.ufl
-                         TARGET laplace_symdiff
-                         )
-
-dune_add_system_test(TARGET laplace_symdiff
-                     INIFILE laplace_symdiff.mini)
-
-
-add_generated_executable(UFLFILE laplace_dg.ufl
-                         TARGET laplace_dg_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
-
-dune_add_system_test(TARGET laplace_dg_numdiff
-                     INIFILE laplace_dg_numdiff.mini)
-
-add_generated_executable(UFLFILE laplace_dg.ufl
-                         TARGET laplace_dg_symdiff
-                         )
-
-dune_add_system_test(TARGET laplace_dg_symdiff
-                     INIFILE laplace_dg_symdiff.mini)
+dune_add_formcompiler_system_test(UFLFILE laplace_dg.ufl
+                                  BASENAME laplace_dg
+                                  INIFILE laplace_dg.mini)
 
 add_executable(laplace_dg_ref reference_main.cc)
 set_target_properties(laplace_dg_ref PROPERTIES EXCLUDE_FROM_ALL 1)

test/laplace/laplace_numdiff.mini → test/laplace/laplace.mini

-__name = laplace_numdiff
+__name = laplace_{__exec_suffix}
+__exec_suffix = symdiff, numdiff | expand num
 
 lowerleft = 0.0 0.0
 upperright = 1.0 1.0
 elements = 4 4
 elementType = simplical
 printmatrix = true
+
+[formcompiler]
+numerical_jacobian = 0, 1 | expand num

test/laplace/laplace_dg_symdiff.mini → test/laplace/laplace_dg.mini

-__name = laplace_dg_symdiff
+__name = laplace_dg_{__exec_suffix}
+__exec_suffix = numdiff, symdiff | expand num
 
 lowerleft = 0.0 0.0
 upperright = 1.0 1.0
@@ -6,3 +7,5 @@ elements = 2 2
 elementType = simplical
 printmatrix = true
 
+[formcompiler]
+numerical_jacobian = 1, 0 | expand num

test/laplace/laplace_dg_numdiff.mini

-__name = laplace_dg_numdiff
-
-lowerleft = 0.0 0.0
-upperright = 1.0 1.0
-elements = 2 2
-elementType = simplical
-printmatrix = true

test/laplace/laplace_symdiff.mini

-__name = laplace_symdiff
-
-lowerleft = 0.0 0.0
-upperright = 1.0 1.0
-elements = 4 4
-elementType = simplical
-printmatrix = true

test/nonlinear/CMakeLists.txt

-add_generated_executable(UFLFILE nonlinear.ufl
-                         TARGET nonlinear_symdiff
-                         FORM_COMPILER_ARGS
-                         )
-
-dune_add_system_test(TARGET nonlinear_symdiff
-                     INIFILE nonlinear_symdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-add_generated_executable(UFLFILE nonlinear_dg.ufl
-                         TARGET nonlinear_dg
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-1 --compare-l2errorsquared 1e-3
-                         )
-
-dune_add_system_test(TARGET nonlinear_dg
-                     INIFILE nonlinear_dg.mini
-                     )
+dune_add_formcompiler_system_test(UFLFILE nonlinear.ufl
+                                  BASENAME nonlinear
+                                  INIFILE nonlinear.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+dune_add_formcompiler_system_test(UFLFILE nonlinear_dg.ufl
+                                  BASENAME nonlinear_dg
+                                  INIFILE nonlinear_dg.mini
+                                  )
 
 # Add the reference code with the PDELab localoperator that produced
 # the reference vtk file

test/nonlinear/nonlinear_dg.mini

@@ -9,3 +9,8 @@ elementType = simplical
 name = {__name}
 reference = nonlinear_dg
 extension = vtu
+
+[formcompiler]
+exact_solution_expression = g
+compare_dofs = 1e-1
+compare_l2errorsquared = 1e-3

test/poisson/CMakeLists.txt

@@ -6,141 +6,53 @@ dune_symlink_to_source_files(FILES poisson_ref.vtu
                              )
 
 
-# 1. Poisson Test Case: source f, bc g + numerical differentiation
-add_generated_executable(UFLFILE poisson.ufl
-                         TARGET poisson_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
-
-dune_add_system_test(TARGET poisson_numdiff
-                     INIFILE poisson_numdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-
-# 2. Poisson Test Case: source f, bc g + symbolic differentiation
-add_generated_executable(UFLFILE poisson.ufl
-                         TARGET poisson_symdiff
-                         )
-
-dune_add_system_test(TARGET poisson_symdiff
-                     INIFILE poisson_symdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# 3. Poisson Test Case: source f, mixed neumann/dirichlet boundary + numerical differentiation
-add_generated_executable(UFLFILE poisson_neumann.ufl
-                         TARGET poisson_neumann_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
-
-dune_add_system_test(TARGET poisson_neumann_numdiff
-                     INIFILE poisson_neumann_numdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# 4. Poisson Test Case: source f, mixed neumann/dirichlet boundary + symbolic differentiation
-add_generated_executable(UFLFILE poisson_neumann.ufl
-                         TARGET poisson_neumann_symdiff
-                         )
-
-dune_add_system_test(TARGET poisson_neumann_symdiff
-                     INIFILE poisson_neumann_symdiff.mini
-                     )
-
-# 5. Poisson Test Case: DG, f + pure dirichlet, numeric differentiation
-add_generated_executable(UFLFILE poisson_dg.ufl
-                         TARGET poisson_dg_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
-
-dune_add_system_test(TARGET poisson_dg_numdiff
-                     INIFILE poisson_dg_numdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# 6. Poisson Test Case: DG, f + pure dirichlet, symbolic differentiation
-add_generated_executable(UFLFILE poisson_dg.ufl
-                         TARGET poisson_dg_symdiff
-                         )
-
-dune_add_system_test(TARGET poisson_dg_symdiff
-                     INIFILE poisson_dg_symdiff.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# 7. Poisson Test Case: DG, mixed bc, numeric differentiation
-add_generated_executable(UFLFILE poisson_dg_neumann.ufl
-                         TARGET poisson_dg_neumann_numdiff
-                         FORM_COMPILER_ARGS --numerical-jacobian
-                         )
-
-dune_add_system_test(TARGET poisson_dg_neumann_numdiff
-                     INIFILE poisson_dg_neumann_numdiff.mini
-                     )
-
-# 8. Poisson Test Case: DG, mixed bc, symbolic differentiation
-add_generated_executable(UFLFILE poisson_dg_neumann.ufl
-                         TARGET poisson_dg_neumann_symdiff
-                         )
-
-dune_add_system_test(TARGET poisson_dg_neumann_symdiff
-                     INIFILE poisson_dg_neumann_symdiff.mini
-                     )
-
-# 9. Poisson Test Case: matrix free, numeric differentiation
-add_generated_executable(UFLFILE poisson.ufl
-                         TARGET poisson_numdiff_matrix_free
-                         FORM_COMPILER_ARGS --numerical-jacobian --matrix-free
-                         )
-
-dune_add_system_test(TARGET poisson_numdiff_matrix_free
-                     INIFILE poisson_numdiff_matrix_free.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# 10. Poisson Test Case: matrix free, symbolic differentiation
-add_generated_executable(UFLFILE poisson.ufl
-                         TARGET poisson_symdiff_matrix_free
-                         FORM_COMPILER_ARGS --matrix-free
-                         )
-
-dune_add_system_test(TARGET poisson_symdiff_matrix_free
-                     INIFILE poisson_symdiff_matrix_free.mini
-                     SCRIPT dune_vtkcompare.py
-                     )
-
-# # 11. Poisson Test Case: dg, matrix free, numeric differentiation
-# add_generated_executable(UFLFILE poisson_dg.ufl
-#                          TARGET poisson_dg_numdiff_matrix_free
-#                          FORM_COMPILER_ARGS --numerical-jacobian --matrix-free
-#                          )
-
-# dune_add_system_test(TARGET poisson_dg_numdiff_matrix_free
-#                      INIFILE poisson_dg_numdiff_matrix_free.mini
-#                      SCRIPT dune_vtkcompare.py
-#                      )
-
-# # 12. Poisson Test Case: dg, matrix free, symbolic differentiation
-# add_generated_executable(UFLFILE poisson_dg.ufl
-#                          TARGET poisson_dg_symdiff_matrix_free
-#                          FORM_COMPILER_ARGS --matrix-free
-#                          )
-
-# dune_add_system_test(TARGET poisson_dg_symdiff_matrix_free
-#                      INIFILE poisson_dg_symdiff_matrix_free.mini
-#                      SCRIPT dune_vtkcompare.py
-#                      )
-
-
-# 13. Poisson Test Case: test constant expressions
-add_generated_executable(UFLFILE poisson_cellwise_constant.ufl
-                         TARGET poisson_cellwise_constant
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-l2errorsquared 1e-6
-                         )
-dune_add_system_test(TARGET poisson_cellwise_constant
-                     INIFILE poisson_cellwise_constant.mini
-                     )
+# 1. Poisson Test Case: source f, bc g
+dune_add_formcompiler_system_test(UFLFILE poisson.ufl
+                                  BASENAME poisson
+                                  INIFILE poisson.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+# 2. Poisson Test Case: source f, mixed neumann/dirichlet boundary
+dune_add_formcompiler_system_test(UFLFILE poisson_neumann.ufl
+                                  BASENAME poisson_neumann
+                                  INIFILE poisson_neumann.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+# 3. Poisson Test Case: DG, f + pure dirichlet
+dune_add_formcompiler_system_test(UFLFILE poisson_dg.ufl
+                                  BASENAME poisson_dg
+                                  INIFILE poisson_dg.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+# 4. Poisson Test Case: DG, mixed bc
+dune_add_formcompiler_system_test(UFLFILE poisson_dg_neumann.ufl
+                                  BASENAME poisson_dg_neumann
+                                  INIFILE poisson_dg_neumann.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+# 5. Poisson Test Case: matrix free
+dune_add_formcompiler_system_test(UFLFILE poisson.ufl
+                                  BASENAME poisson_matrix_free
+                                  INIFILE poisson_matrix_free.mini
+                                  SCRIPT dune_vtkcompare.py
+                                  )
+
+# 6. Poisson Test Case: DG, matrix free
+#dune_add_formcompiler_system_test(UFLFILE poisson_dg.ufl
+#                                  BASENAME poisson_dg_matrix_free
+#                                  INIFILE poisson_dg_matrix_free.mini
+#                                  SCRIPT dune_vtkcompare.py
+#                                  )
+
+# 7. Poisson Test Case: test constant expressions
+dune_add_formcompiler_system_test(UFLFILE poisson_cellwise_constant.ufl
+                                  BASENAME poisson_cellwise_constant
+                                  INIFILE poisson_cellwise_constant.mini
+                                  )
 
 # Add the reference code with the PDELab localoperator that produced
 # the reference vtk file

test/poisson/dimension-grid-variations/CMakeLists.txt

@@ -2,102 +2,60 @@
 # 1D Tests: cg/dg
 #================
 
-add_generated_executable(UFLFILE poisson_1d_cg_interval.ufl
-                         TARGET poisson_1d_cg_interval
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-14 --compare-l2errorsquared 1e-7
-                         )
-
-dune_add_system_test(TARGET poisson_1d_cg_interval
-                     INIFILE poisson_1d_cg_interval.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_1d_dg_interval.ufl
-                         TARGET poisson_1d_dg_interval
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-2 --compare-l2errorsquared 1e-5
-                         )
-
-dune_add_system_test(TARGET poisson_1d_dg_interval
-                     INIFILE poisson_1d_dg_interval.mini
-                     )
+dune_add_formcompiler_system_test(UFLFILE poisson_1d_cg_interval.ufl
+                                  BASENAME poisson_1d_cg_interval
+                                  INIFILE poisson_1d_cg_interval.mini
+                                  )
 
+dune_add_formcompiler_system_test(UFLFILE poisson_1d_dg_interval.ufl
+                                  BASENAME poisson_1d_dg_interval
+                                  INIFILE poisson_1d_dg_interval.mini
+                                  )
 
 #========================================
 # 2D Tests: cg/dg, triangle/quadrilateral
 #========================================
 
-add_generated_executable(UFLFILE poisson_2d_cg_triangle.ufl
-                         TARGET poisson_2d_cg_triangle
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-14 --compare-l2errorsquared 1e-6
-                         )
-
-dune_add_system_test(TARGET poisson_2d_cg_triangle
-                     INIFILE poisson_2d_cg_triangle.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_2d_dg_triangle.ufl
-                         TARGET poisson_2d_dg_triangle
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-1 --compare-l2errorsquared 1e-4
-                         )
-
-dune_add_system_test(TARGET poisson_2d_dg_triangle
-                     INIFILE poisson_2d_dg_triangle.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_2d_cg_quadrilateral.ufl
-                         TARGET poisson_2d_cg_quadrilateral
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-14 --compare-l2errorsquared 1e-6
-                         )
-
-dune_add_system_test(TARGET poisson_2d_cg_quadrilateral
-                     INIFILE poisson_2d_cg_quadrilateral.mini
-                     )
+dune_add_formcompiler_system_test(UFLFILE poisson_2d_cg_triangle.ufl
+                                  BASENAME poisson_2d_cg_triangle
+                                  INIFILE poisson_2d_cg_triangle.mini
+                                  )
 
-add_generated_executable(UFLFILE poisson_2d_dg_quadrilateral.ufl
-                         TARGET poisson_2d_dg_quadrilateral
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-1 --compare-l2errorsquared 1e-4
-                         )
+dune_add_formcompiler_system_test(UFLFILE poisson_2d_dg_triangle.ufl
+                                  BASENAME poisson_2d_dg_triangle
+                                  INIFILE poisson_2d_dg_triangle.mini
+                                  )
 
-dune_add_system_test(TARGET poisson_2d_dg_quadrilateral
-                     INIFILE poisson_2d_dg_quadrilateral.mini
-                     )
+dune_add_formcompiler_system_test(UFLFILE poisson_2d_cg_quadrilateral.ufl
+                                  BASENAME poisson_2d_cg_quadrilateral
+                                  INIFILE poisson_2d_cg_quadrilateral.mini
+                                  )
 
+dune_add_formcompiler_system_test(UFLFILE poisson_2d_dg_quadrilateral.ufl
+                                  BASENAME poisson_2d_dg_quadrilateral
+                                  INIFILE poisson_2d_dg_quadrilateral.mini
+                                  )
 
 #========================================
 # 3D Tests: cg/dg, tetrahedron/hexahedron
 #========================================
 
-add_generated_executable(UFLFILE poisson_3d_cg_tetrahedron.ufl
-                         TARGET poisson_3d_cg_tetrahedron
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-14 --compare-l2errorsquared 1e-4
-                         )
-
-dune_add_system_test(TARGET poisson_3d_cg_tetrahedron
-                     INIFILE poisson_3d_cg_tetrahedron.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_3d_dg_tetrahedron.ufl
-                         TARGET poisson_3d_dg_tetrahedron
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-2 --compare-l2errorsquared 1e-4
-                         )
-
-dune_add_system_test(TARGET poisson_3d_dg_tetrahedron
-                     INIFILE poisson_3d_dg_tetrahedron.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_3d_cg_hexahedron.ufl
-                         TARGET poisson_3d_cg_hexahedron
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1e-14 --compare-l2errorsquared 1e-4
-                         )
-
-dune_add_system_test(TARGET poisson_3d_cg_hexahedron
-                     INIFILE poisson_3d_cg_hexahedron.mini
-                     )
-
-add_generated_executable(UFLFILE poisson_3d_dg_hexahedron.ufl
-                         TARGET poisson_3d_dg_hexahedron
-                         FORM_COMPILER_ARGS --exact-solution-expression g --compare-dofs 1 --compare-l2errorsquared 1e-3
-                         )
-
-dune_add_system_test(TARGET poisson_3d_dg_hexahedron
-                     INIFILE poisson_3d_dg_hexahedron.mini
-                     )
+dune_add_formcompiler_system_test(UFLFILE poisson_3d_cg_tetrahedron.ufl
+                                  BASENAME poisson_3d_cg_tetrahedron
+                                  INIFILE poisson_3d_cg_tetrahedron.mini
+                                  )
+
+dune_add_formcompiler_system_test(UFLFILE poisson_3d_dg_tetrahedron.ufl
+                                  BASENAME poisson_3d_dg_tetrahedron
+                                  INIFILE poisson_3d_dg_tetrahedron.mini
+                                  )
+
+dune_add_formcompiler_system_test(UFLFILE poisson_3d_cg_hexahedron.ufl
+                                  BASENAME poisson_3d_cg_hexahedron
+                                  INIFILE poisson_3d_cg_hexahedron.mini
+                                  )
+
+dune_add_formcompiler_system_test(UFLFILE poisson_3d_dg_hexahedron.ufl
+                                  BASENAME poisson_3d_dg_hexahedron
+                                  INIFILE poisson_3d_dg_hexahedron.mini
+                                  )

test/poisson/dimension-grid-variations/poisson_1d_cg_interval.mini

@@ -6,3 +6,8 @@ extension = 1.
 [wrapper.vtkcompare]
 name = {__name}
 extension = vtu
+
+[formcompiler]
+exact_solution_expression = g
+compare_dofs = 1e-14
+compare_l2errorsquared = 1e-7

test/poisson/dimension-grid-variations/poisson_1d_dg_interval.mini

@@ -6,3 +6,8 @@ extension = 1.
 [wrapper.vtkcompare]
 name = {__name}
 extension = vtu
+
+[formcompiler]
+exact_solution_expression = g
+compare_dofs = 1e-2
+compare_l2errorsquared = 1e-5