diff --git a/bin/fuzzycomparevtu.py b/bin/fuzzycomparevtu.py
index 82552bef40468a0be0ba34b1f2f18f95e2a394cf..3b55a1b7631d62462957343dd526f89a6dc3b81d 100644
--- a/bin/fuzzycomparevtu.py
+++ b/bin/fuzzycomparevtu.py
@@ -1,349 +1,7 @@
-""" A module for fuzzy comparing VTK files.
-
-This module provides methods to compare two VTK files. Applicable
-for all VTK style formats like VTK files. Fuzzy compares numbers by
-using absolute and/or relative difference comparison.
-
-"""
-from __future__ import absolute_import
-import argparse
-import xml.etree.ElementTree as ET
-from operator import attrgetter, itemgetter
 import sys
-from six.moves import range
-from six.moves import zip
-
-
-# fuzzy compare VTK tree from VTK strings
-def compare_vtk(vtk1, vtk2, absolute=1.5e-7, relative=1e-2, zeroValueThreshold={}, verbose=True):
-    """ take two vtk files and compare them. Returns an exit key as returnvalue.
-
-    Arguments:
-    ----------
-    vtk1, vtk2 : string
-        The filenames of the vtk files to compare
-
-    Keyword Arguments:
-    ------------------
-    absolute : float
-        The epsilon used for comparing numbers with an absolute criterion
-    relative: float
-        The epsilon used for comparing numbers with an relative criterion
-    zeroValueThreshold: dict
-        A dictionary of parameter value pairs that set the threshold under
-        which a number is treated as zero for a certain parameter. Use this parameter if
-        you have to avoid comparisons of very small numbers for a certain parameter.
-    verbose : bool
-        If the script should produce informative output. Enabled by default as the details
-        give the tester a lot more information on why tests fail.
-    """
-
-    # construct element tree from vtk file
-    root1 = ET.fromstring(open(vtk1).read())
-    root2 = ET.fromstring(open(vtk2).read())
-
-    # sort the vtk file in case nodes appear in different positions
-    # e.g. because of minor changes in the output code
-    sortedroot1 = sort_vtk(root1)
-    sortedroot2 = sort_vtk(root2)
-
-    if verbose:
-        print("Comparing {} and {}".format(vtk1, vtk2))
-        print("... with a maximum relative error of {} and a maximum absolute error of {}*max_abs_parameter_value.".format(relative, absolute))
-
-    # sort the vtk file so that the comparison is independent of the
-    # index numbering (coming e.g. from different grid managers)
-    sortedroot1, sortedroot2 = sort_vtk_by_coordinates(sortedroot1, sortedroot2, verbose)
-
-    # do the fuzzy compare
-    if is_fuzzy_equal_node(sortedroot1, sortedroot2, absolute, relative, zeroValueThreshold, verbose):
-        return 0
-    else:
-        return 1
-
-
-# fuzzy compare of VTK nodes
-def is_fuzzy_equal_node(node1, node2, absolute, relative, zeroValueThreshold, verbose):
-
-    is_equal = True
-    for node1child, node2child in zip(node1.iter(), node2.iter()):
-        if node1.tag != node2.tag:
-            if verbose:
-                print('The name of the node differs in: {} and {}'.format(node1.tag, node2.tag))
-                is_equal = False
-            else:
-                return False
-        if list(node1.attrib.items()) != list(node2.attrib.items()):
-            if verbose:
-                print('Attributes differ in node: {}'.format(node1.tag))
-                is_equal = False
-            else:
-                return False
-        if len(list(node1.iter())) != len(list(node2.iter())):
-            if verbose:
-                print('Number of children differs in node: {}'.format(node1.tag))
-                is_equal = False
-            else:
-                return False
-        if node1child.text or node2child.text:
-            if not is_fuzzy_equal_text(node1child.text, node2child.text,
-                                       node1child.attrib["Name"],
-                                       int(node1child.attrib["NumberOfComponents"]),
-                                       absolute, relative, zeroValueThreshold, verbose):
-                if node1child.attrib["Name"] == node2child.attrib["Name"]:
-                    if verbose:
-                        is_equal = False
-                    else:
-                        return False
-                else:
-                    if verbose:
-                        print('Comparing different parameters: {} and {}'.format(node1child.attrib["Name"], node2child.attrib["Name"]))
-                        is_equal = False
-                    else:
-                        return False
-    return is_equal
-
-
-# fuzzy compare of text (in the xml sense) consisting of whitespace separated numbers
-def is_fuzzy_equal_text(text1, text2, parameter, numComp, absolute, relative, zeroValueThreshold, verbose):
-    list1 = text1.split()
-    list2 = text2.split()
-    # difference only in whitespace?
-    if (list1 == list2):
-        return True
-    # compare number by number
-    is_equal = True
-
-    # first split the list into compononents
-    lists1 = []
-    lists2 = []
-    parameters = []
-    for i in range(0, numComp):
-        lists1.append(list1[i::numComp])
-        lists2.append(list2[i::numComp])
-        if numComp > 1:
-            parameters.append("{}_{}".format(parameter, i))
-            # if zero threshold was set for all components one component inherits it from the parameter
-            if parameter in zeroValueThreshold:
-                zeroValueThreshold["{}_{}".format(parameter, i)] = zeroValueThreshold[parameter]
-        else:
-            parameters.append(parameter)
-
-    for list1, list2, parameter in zip(lists1, lists2, parameters):
-        # for verbose output
-        max_relative_difference = 0.0
-        message = ''
-
-        # see inspiration, explanations in
-        # https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
-        # get the order of magnitude of the parameter by calculating the max
-        floatList1 = [float(i) for i in list1]
-        floatList2 = [float(i) for i in list2]
-
-        # manipulate the data set for the sake of sensible comparison
-        # if the parameter is listed in the zeroThreshold dictionary replace all float under threshold with zero.
-        # only replace them with zero if the parameters in both lists are under the threshold. Otherwise we
-        # compare a non-zero value with 0 later.
-        if parameter in zeroValueThreshold:
-            floatList1 = [0.0 if abs(i) < float(zeroValueThreshold[parameter]) and abs(j) < float(zeroValueThreshold[parameter])
-                          else i for i, j in zip(floatList1, floatList2)]
-            floatList2 = [0.0 if abs(i) < float(zeroValueThreshold[parameter]) and abs(j) < float(zeroValueThreshold[parameter])
-                          else j for i, j in zip(floatList1, floatList2)]
-
-        absFloatList1 = [abs(i) for i in floatList1]
-        absFloatList2 = [abs(i) for i in floatList2]
-
-        magnitude = max(max(absFloatList1), max(absFloatList2))
-        minimal = min(min(absFloatList1), min(absFloatList2))
-
-        for number1, number2 in zip(floatList1, floatList2):
-            diff = abs(number1 - number2)
-            largernumber = max(abs(number1), abs(number2))
-
-            # If the absolute criterion is satisfied we consider the numbers equal...
-            # scale the absolute tolerance with the magnitude of the parameter
-            if diff <= absolute * magnitude:
-                continue
-
-            # ...if not check the relative criterion
-            if diff <= largernumber * relative:
-                continue
-            else:
-                # the numbers are not equal
-                if verbose:
-                    is_equal = False
-                    if largernumber != 0.0:
-                        if diff / largernumber > max_relative_difference:
-                            max_relative_difference = diff / largernumber
-                            message = 'Difference is too large: {:.2%} -> between: {} and {}'.format(max_relative_difference, number1, number2)
-                else:
-                    return False
-
-        if verbose and max_relative_difference != 0.0:
-            print('\nData differs in parameter: {}'.format(parameter))
-            print(message)
-            print('Info for {}: max_abs_parameter_value={} and min_abs_parameter_value={}.'.format(parameter, magnitude, minimal))
-            if parameter in zeroValueThreshold:
-                print('For parameter {} a zero value threshold of {} was given.'.format(parameter, zeroValueThreshold[parameter]))
-
-    return is_equal
-
-
-def sort_by_name(elem):
-    name = elem.get('Name')
-    if name:
-        try:
-            return str(name)
-        except ValueError:
-            return ''
-    return ''
-
-
-# sorts attributes of an item and returns a sorted item
-def sort_attributes(item, sorteditem):
-    attrkeys = sorted(item.keys())
-    for key in attrkeys:
-        sorteditem.set(key, item.get(key))
-
-
-def sort_elements(items, newroot):
-    items = sorted(items, key=sort_by_name)
-    items = sorted(items, key=attrgetter('tag'))
-
-    # Once sorted, we sort each of the items
-    for item in items:
-        # Create a new item to represent the sorted version
-        # of the next item, and copy the tag name and contents
-        newitem = ET.Element(item.tag)
-        if item.text and item.text.isspace() == False:
-            newitem.text = item.text
-
-        # Copy the attributes (sorted by key) to the new item
-        sort_attributes(item, newitem)
-
-        # Copy the children of item (sorted) to the new item
-        sort_elements(list(item), newitem)
-
-        # Append this sorted item to the sorted root
-        newroot.append(newitem)
-
-
-# has to sort all Cell and Point Data after the attribute "Name"!
-def sort_vtk(root):
-    if(root.tag != "VTKFile"):
-        print('Format is not a VTKFile. Sorting will most likely fail!')
-    # create a new root for the sorted tree
-    newroot = ET.Element(root.tag)
-    # create the sorted copy
-    # (after the idea of Dale Lane's xmldiff.py)
-    sort_attributes(root, newroot)
-    sort_elements(list(root), newroot)
-    # return the sorted element tree
-    return newroot
-
-
-# sorts the data by point coordinates so that it is independent of index numbering
-def sort_vtk_by_coordinates(root1, root2, verbose):
-    if not is_fuzzy_equal_node(root1.find(".//Points/DataArray"), root2.find(".//Points/DataArray"), absolute=1e-2, relative=1.5e-7, zeroValueThreshold=dict(), verbose=False):
-        if verbose:
-            print("Sorting vtu by coordinates...")
-        for root in [root1, root2]:
-            # parse all DataArrays in a dictionary
-            pointDataArrays = []
-            cellDataArrays = []
-            dataArrays = {}
-            numberOfComponents = {}
-            for dataArray in root.findall(".//PointData/DataArray"):
-                pointDataArrays.append(dataArray.attrib["Name"])
-            for dataArray in root.findall(".//CellData/DataArray"):
-                cellDataArrays.append(dataArray.attrib["Name"])
-            for dataArray in root.findall(".//DataArray"):
-                dataArrays[dataArray.attrib["Name"]] = dataArray.text
-                numberOfComponents[dataArray.attrib["Name"]] = dataArray.attrib["NumberOfComponents"]
-
-            vertexArray = []
-            coords = dataArrays["Coordinates"].split()
-            # group the coordinates into coordinate tuples
-            dim = int(numberOfComponents["Coordinates"])
-            for i in range(len(coords) // dim):
-                vertexArray.append([float(c) for c in coords[i * dim: i * dim + dim]])
-
-            # obtain a vertex index map
-            vMap = []
-            for idx, coords in enumerate(vertexArray):
-                vMap.append((idx, coords))
-            sortedVMap = sorted(vMap, key=itemgetter(1))
-            vertexIndexMap = {}
-            for idxNew, idxOld in enumerate(sortedVMap):
-                vertexIndexMap[idxOld[0]] = idxNew
-
-            # group the cells into vertex index tuples
-            cellArray = []
-            offsets = dataArrays["offsets"].split()
-            connectivity = dataArrays["connectivity"].split()
-            vertex = 0
-            for cellIdx, offset in enumerate(offsets):
-                cellArray.append([])
-                for v in range(vertex, int(offset)):
-                    cellArray[cellIdx].append(int(connectivity[v]))
-                    vertex += 1
-
-            # replace all vertex indices in the cellArray by the new indices
-            for cell in cellArray:
-                for idx, vertexIndex in enumerate(cell):
-                    cell[idx] = vertexIndexMap[vertexIndex]
-
-            # sort all data arrays
-            for name, text in list(dataArrays.items()):
-                # split the text
-                items = text.split()
-                # convert if vector
-                num = int(numberOfComponents[name])
-                newitems = []
-                for i in range(len(items) // num):
-                    newitems.append([i for i in items[i * num: i * num + num]])
-                items = newitems
-                # sort the items: we have either vertex or cell data
-                if name in pointDataArrays:
-                    sortedItems = [j for (i, j) in sorted(zip(vertexArray, items), key=itemgetter(0))]
-                elif name in cellDataArrays or name == "types":
-                    sortedItems = [j for (i, j) in sorted(zip(cellArray, items), key=itemgetter(0))]
-                elif name == "offsets":
-                    sortedItems = []
-                    counter = 0
-                    for cell in sorted(cellArray):
-                        counter += len(cell)
-                        sortedItems.append([str(counter)])
-                elif name == "Coordinates":
-                    sortedItems = sorted(vertexArray)
-                elif name == "connectivity":
-                    sortedItems = sorted(cellArray)
-
-                # convert the sorted arrays to a xml text
-                dataArrays[name] = ""
-                for i in sortedItems:
-                    for j in i:
-                        dataArrays[name] += str(j) + " "
-
-            # do the replacement in the actual elements
-            for dataArray in root.findall(".//DataArray"):
-                dataArray.text = dataArrays[dataArray.attrib["Name"]]
-
-    return (root1, root2)
-
-
-# main program if called as script return appropriate error codes
-if __name__ == "__main__":
-    # handle arguments and print help message
-    parser = argparse.ArgumentParser(description='Fuzzy compare of two VTK\
-        (Visualization Toolkit) files. The files are accepted if for every\
-        value the difference is below the absolute error or below the\
-        relative error or below both.')
-    parser.add_argument('vtk_file_1', type=str, help='first file to compare')
-    parser.add_argument('vtk_file_2', type=str, help='second file to compare')
-    parser.add_argument('-r', '--relative', type=float, default=1e-2, help='maximum relative error (default=1e-2)')
-    parser.add_argument('-a', '--absolute', type=float, default=1.5e-7, help='maximum absolute error (default=1.5e-7)')
-    parser.add_argument('-v', '--verbose', type=bool, default=True, help='verbosity of the script')
-    args = vars(parser.parse_args())
-
-    sys.exit(compare_vtk(args["vtk_file_1"], args["vtk_file_2"], args["absolute"], args["relative"], args["verbose"]))
+print("\n")
+print("#########################################################################################\n")
+print("# Warning: bin/fuzzycomparevtu.py is deprecated and will be deleted after release 2.10. #\n")
+print("#          bin/testing/fuzzycomparevtu.py instead.                                      #\n")
+print("#########################################################################################\n")
+sys.exit(1)
diff --git a/bin/runtest.py b/bin/runtest.py
index c09d586537f50f07ff614a17f3a4f4e43f8872b9..7cc4a82ebe1ed7657ef8b168710c624c1bcbe11f 100644
--- a/bin/runtest.py
+++ b/bin/runtest.py
@@ -1,75 +1,8 @@
-import argparse
-import os, sys
-import subprocess
-import json
-from fuzzycomparevtu import compare_vtk
-
-# parse arguments
-parser = argparse.ArgumentParser()
-parser.add_argument('-c', '--command', nargs=1, help='The executable and optional arguments as a single string', required=True)
-parser.add_argument('-s', '--script', nargs=1, help="The comparison script. [fuzzy, exact, <path_to_script>] where the script takes two vtu files as arguments.")
-parser.add_argument('-f', '--files', nargs='+', help="Pairs of reference and vtu file names. Usage: '[-f ref1 vtu1 [[ref2] [vtu2] ...]]'")
-parser.add_argument('-r', '--relative', type=float, default=1e-2, help='maximum relative error (default=1e-2) when using fuzzy comparison')
-parser.add_argument('-a', '--absolute', type=float, default=1.5e-7, help='maximum absolute error (default=1.5e-7) when using fuzzy comparison')
-parser.add_argument('-z', '--zeroThreshold', type=json.loads, default='{}', help='Thresholds for treating numbers as zero for a parameter as a python dict e.g. {"vel":1e-7,"delP":1.0}')
-args = vars(parser.parse_args())
-
-# check parameters
-if args['script']:
-    if len(args['files'])%2 != 0 or not args['files']:
-        sys.stderr.write("The files have to be pairs of vtu and reference files. Usage '-f [ref1] [vtu1] [[ref2] [vtu2] ...]'")
-        parser.print_help()
-        sys.exit(1)
-    for i in range(0, len(args['files'])//2):
-        # delete the vtu files to compare
-        ref_dir = os.path.dirname(os.path.abspath(__file__)).rstrip("bin") + "test/references"
-        if os.path.dirname(args['files'][(i*2)+1]) == ref_dir:
-            sys.stderr.write("Tried to delete a reference solution. Specify reference file first, then the VTU file. Usage: '[-f ref1 vtu1 [[ref2] [vtu2] ...]]'")
-            sys.exit(1)
-        subprocess.call(['rm', '-fv', args['files'][(i*2)+1]])
-
-# run the test
-res = 1
-try:
-    res = subprocess.call(args['command'][0].split())
-except OSError as e:
-    print(args['command'][0].split())
-    print("OSError: Command not found. Most likely the executable specified doesn't exist.")
-    sys.exit(1)
-if res:
-    sys.exit(res)
-
-# run the comparison
-if args['script']:
-    # exact comparison?
-    if args['script'] == ['exact']:
-        return_code = 0
-        for i in range(0, len(args['files'])//2):
-            print("\nExact comparison...")
-            result = subprocess.call(['diff', args['files'][i*2], args['files'][(i*2)+1]])
-            if result:
-                return_code = 1
-        sys.exit(return_code)
-
-    # fuzzy comparison?
-    elif args['script'] == ["fuzzy"] or args['script'] == [os.path.dirname(os.path.abspath(__file__)) + "/fuzzycomparevtu.py"]:
-        return_code = 0
-        for i in range(0, len(args['files'])//2):
-            print("\nFuzzy comparison...")
-            result = compare_vtk(args['files'][i*2], args['files'][(i*2)+1], relative=args['relative'], absolute=args['absolute'], zeroValueThreshold=args['zeroThreshold'])
-            if result:
-                return_code = 1
-        sys.exit(return_code)
-
-    # other script?
-    else:
-        return_code = 0
-        for i in range(0, len(args['files'])//2):
-            print("\n{} comparison...".format(args['script']))
-            result = subprocess.call(args['script'], args['files'][i*2], args['files'][(i*2)+1])
-            if result:
-                return_code = 1
-        sys.exit(return_code)
-
-# everything is fine
-sys.exit(0)
+import sys
+print("")
+print("#################################################################################")
+print("# Warning: bin/runtest.py is deprecated and will be deleted after release 2.10. #")
+print("#          Use bin/testing/runtest.py instead.                                  #")
+print("#################################################################################")
+print("")
+sys.exit(1)
diff --git a/bin/testing/fuzzycomparevtu.py b/bin/testing/fuzzycomparevtu.py
new file mode 100644
index 0000000000000000000000000000000000000000..82552bef40468a0be0ba34b1f2f18f95e2a394cf
--- /dev/null
+++ b/bin/testing/fuzzycomparevtu.py
@@ -0,0 +1,349 @@
+""" A module for fuzzy comparing VTK files.
+
+This module provides methods to compare two VTK files. Applicable
+for all VTK style formats like VTK files. Fuzzy compares numbers by
+using absolute and/or relative difference comparison.
+
+"""
+from __future__ import absolute_import
+import argparse
+import xml.etree.ElementTree as ET
+from operator import attrgetter, itemgetter
+import sys
+from six.moves import range
+from six.moves import zip
+
+
+# fuzzy compare VTK tree from VTK strings
+def compare_vtk(vtk1, vtk2, absolute=1.5e-7, relative=1e-2, zeroValueThreshold={}, verbose=True):
+    """ take two vtk files and compare them. Returns an exit key as returnvalue.
+
+    Arguments:
+    ----------
+    vtk1, vtk2 : string
+        The filenames of the vtk files to compare
+
+    Keyword Arguments:
+    ------------------
+    absolute : float
+        The epsilon used for comparing numbers with an absolute criterion
+    relative: float
+        The epsilon used for comparing numbers with an relative criterion
+    zeroValueThreshold: dict
+        A dictionary of parameter value pairs that set the threshold under
+        which a number is treated as zero for a certain parameter. Use this parameter if
+        you have to avoid comparisons of very small numbers for a certain parameter.
+    verbose : bool
+        If the script should produce informative output. Enabled by default as the details
+        give the tester a lot more information on why tests fail.
+    """
+
+    # construct element tree from vtk file
+    root1 = ET.fromstring(open(vtk1).read())
+    root2 = ET.fromstring(open(vtk2).read())
+
+    # sort the vtk file in case nodes appear in different positions
+    # e.g. because of minor changes in the output code
+    sortedroot1 = sort_vtk(root1)
+    sortedroot2 = sort_vtk(root2)
+
+    if verbose:
+        print("Comparing {} and {}".format(vtk1, vtk2))
+        print("... with a maximum relative error of {} and a maximum absolute error of {}*max_abs_parameter_value.".format(relative, absolute))
+
+    # sort the vtk file so that the comparison is independent of the
+    # index numbering (coming e.g. from different grid managers)
+    sortedroot1, sortedroot2 = sort_vtk_by_coordinates(sortedroot1, sortedroot2, verbose)
+
+    # do the fuzzy compare
+    if is_fuzzy_equal_node(sortedroot1, sortedroot2, absolute, relative, zeroValueThreshold, verbose):
+        return 0
+    else:
+        return 1
+
+
+# fuzzy compare of VTK nodes
+def is_fuzzy_equal_node(node1, node2, absolute, relative, zeroValueThreshold, verbose):
+
+    is_equal = True
+    for node1child, node2child in zip(node1.iter(), node2.iter()):
+        if node1.tag != node2.tag:
+            if verbose:
+                print('The name of the node differs in: {} and {}'.format(node1.tag, node2.tag))
+                is_equal = False
+            else:
+                return False
+        if list(node1.attrib.items()) != list(node2.attrib.items()):
+            if verbose:
+                print('Attributes differ in node: {}'.format(node1.tag))
+                is_equal = False
+            else:
+                return False
+        if len(list(node1.iter())) != len(list(node2.iter())):
+            if verbose:
+                print('Number of children differs in node: {}'.format(node1.tag))
+                is_equal = False
+            else:
+                return False
+        if node1child.text or node2child.text:
+            if not is_fuzzy_equal_text(node1child.text, node2child.text,
+                                       node1child.attrib["Name"],
+                                       int(node1child.attrib["NumberOfComponents"]),
+                                       absolute, relative, zeroValueThreshold, verbose):
+                if node1child.attrib["Name"] == node2child.attrib["Name"]:
+                    if verbose:
+                        is_equal = False
+                    else:
+                        return False
+                else:
+                    if verbose:
+                        print('Comparing different parameters: {} and {}'.format(node1child.attrib["Name"], node2child.attrib["Name"]))
+                        is_equal = False
+                    else:
+                        return False
+    return is_equal
+
+
+# fuzzy compare of text (in the xml sense) consisting of whitespace separated numbers
+def is_fuzzy_equal_text(text1, text2, parameter, numComp, absolute, relative, zeroValueThreshold, verbose):
+    list1 = text1.split()
+    list2 = text2.split()
+    # difference only in whitespace?
+    if (list1 == list2):
+        return True
+    # compare number by number
+    is_equal = True
+
+    # first split the list into compononents
+    lists1 = []
+    lists2 = []
+    parameters = []
+    for i in range(0, numComp):
+        lists1.append(list1[i::numComp])
+        lists2.append(list2[i::numComp])
+        if numComp > 1:
+            parameters.append("{}_{}".format(parameter, i))
+            # if zero threshold was set for all components one component inherits it from the parameter
+            if parameter in zeroValueThreshold:
+                zeroValueThreshold["{}_{}".format(parameter, i)] = zeroValueThreshold[parameter]
+        else:
+            parameters.append(parameter)
+
+    for list1, list2, parameter in zip(lists1, lists2, parameters):
+        # for verbose output
+        max_relative_difference = 0.0
+        message = ''
+
+        # see inspiration, explanations in
+        # https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+        # get the order of magnitude of the parameter by calculating the max
+        floatList1 = [float(i) for i in list1]
+        floatList2 = [float(i) for i in list2]
+
+        # manipulate the data set for the sake of sensible comparison
+        # if the parameter is listed in the zeroThreshold dictionary replace all float under threshold with zero.
+        # only replace them with zero if the parameters in both lists are under the threshold. Otherwise we
+        # compare a non-zero value with 0 later.
+        if parameter in zeroValueThreshold:
+            floatList1 = [0.0 if abs(i) < float(zeroValueThreshold[parameter]) and abs(j) < float(zeroValueThreshold[parameter])
+                          else i for i, j in zip(floatList1, floatList2)]
+            floatList2 = [0.0 if abs(i) < float(zeroValueThreshold[parameter]) and abs(j) < float(zeroValueThreshold[parameter])
+                          else j for i, j in zip(floatList1, floatList2)]
+
+        absFloatList1 = [abs(i) for i in floatList1]
+        absFloatList2 = [abs(i) for i in floatList2]
+
+        magnitude = max(max(absFloatList1), max(absFloatList2))
+        minimal = min(min(absFloatList1), min(absFloatList2))
+
+        for number1, number2 in zip(floatList1, floatList2):
+            diff = abs(number1 - number2)
+            largernumber = max(abs(number1), abs(number2))
+
+            # If the absolute criterion is satisfied we consider the numbers equal...
+            # scale the absolute tolerance with the magnitude of the parameter
+            if diff <= absolute * magnitude:
+                continue
+
+            # ...if not check the relative criterion
+            if diff <= largernumber * relative:
+                continue
+            else:
+                # the numbers are not equal
+                if verbose:
+                    is_equal = False
+                    if largernumber != 0.0:
+                        if diff / largernumber > max_relative_difference:
+                            max_relative_difference = diff / largernumber
+                            message = 'Difference is too large: {:.2%} -> between: {} and {}'.format(max_relative_difference, number1, number2)
+                else:
+                    return False
+
+        if verbose and max_relative_difference != 0.0:
+            print('\nData differs in parameter: {}'.format(parameter))
+            print(message)
+            print('Info for {}: max_abs_parameter_value={} and min_abs_parameter_value={}.'.format(parameter, magnitude, minimal))
+            if parameter in zeroValueThreshold:
+                print('For parameter {} a zero value threshold of {} was given.'.format(parameter, zeroValueThreshold[parameter]))
+
+    return is_equal
+
+
+def sort_by_name(elem):
+    name = elem.get('Name')
+    if name:
+        try:
+            return str(name)
+        except ValueError:
+            return ''
+    return ''
+
+
+# sorts attributes of an item and returns a sorted item
+def sort_attributes(item, sorteditem):
+    attrkeys = sorted(item.keys())
+    for key in attrkeys:
+        sorteditem.set(key, item.get(key))
+
+
+def sort_elements(items, newroot):
+    items = sorted(items, key=sort_by_name)
+    items = sorted(items, key=attrgetter('tag'))
+
+    # Once sorted, we sort each of the items
+    for item in items:
+        # Create a new item to represent the sorted version
+        # of the next item, and copy the tag name and contents
+        newitem = ET.Element(item.tag)
+        if item.text and item.text.isspace() == False:
+            newitem.text = item.text
+
+        # Copy the attributes (sorted by key) to the new item
+        sort_attributes(item, newitem)
+
+        # Copy the children of item (sorted) to the new item
+        sort_elements(list(item), newitem)
+
+        # Append this sorted item to the sorted root
+        newroot.append(newitem)
+
+
+# has to sort all Cell and Point Data after the attribute "Name"!
+def sort_vtk(root):
+    if(root.tag != "VTKFile"):
+        print('Format is not a VTKFile. Sorting will most likely fail!')
+    # create a new root for the sorted tree
+    newroot = ET.Element(root.tag)
+    # create the sorted copy
+    # (after the idea of Dale Lane's xmldiff.py)
+    sort_attributes(root, newroot)
+    sort_elements(list(root), newroot)
+    # return the sorted element tree
+    return newroot
+
+
+# sorts the data by point coordinates so that it is independent of index numbering
+def sort_vtk_by_coordinates(root1, root2, verbose):
+    if not is_fuzzy_equal_node(root1.find(".//Points/DataArray"), root2.find(".//Points/DataArray"), absolute=1e-2, relative=1.5e-7, zeroValueThreshold=dict(), verbose=False):
+        if verbose:
+            print("Sorting vtu by coordinates...")
+        for root in [root1, root2]:
+            # parse all DataArrays in a dictionary
+            pointDataArrays = []
+            cellDataArrays = []
+            dataArrays = {}
+            numberOfComponents = {}
+            for dataArray in root.findall(".//PointData/DataArray"):
+                pointDataArrays.append(dataArray.attrib["Name"])
+            for dataArray in root.findall(".//CellData/DataArray"):
+                cellDataArrays.append(dataArray.attrib["Name"])
+            for dataArray in root.findall(".//DataArray"):
+                dataArrays[dataArray.attrib["Name"]] = dataArray.text
+                numberOfComponents[dataArray.attrib["Name"]] = dataArray.attrib["NumberOfComponents"]
+
+            vertexArray = []
+            coords = dataArrays["Coordinates"].split()
+            # group the coordinates into coordinate tuples
+            dim = int(numberOfComponents["Coordinates"])
+            for i in range(len(coords) // dim):
+                vertexArray.append([float(c) for c in coords[i * dim: i * dim + dim]])
+
+            # obtain a vertex index map
+            vMap = []
+            for idx, coords in enumerate(vertexArray):
+                vMap.append((idx, coords))
+            sortedVMap = sorted(vMap, key=itemgetter(1))
+            vertexIndexMap = {}
+            for idxNew, idxOld in enumerate(sortedVMap):
+                vertexIndexMap[idxOld[0]] = idxNew
+
+            # group the cells into vertex index tuples
+            cellArray = []
+            offsets = dataArrays["offsets"].split()
+            connectivity = dataArrays["connectivity"].split()
+            vertex = 0
+            for cellIdx, offset in enumerate(offsets):
+                cellArray.append([])
+                for v in range(vertex, int(offset)):
+                    cellArray[cellIdx].append(int(connectivity[v]))
+                    vertex += 1
+
+            # replace all vertex indices in the cellArray by the new indices
+            for cell in cellArray:
+                for idx, vertexIndex in enumerate(cell):
+                    cell[idx] = vertexIndexMap[vertexIndex]
+
+            # sort all data arrays
+            for name, text in list(dataArrays.items()):
+                # split the text
+                items = text.split()
+                # convert if vector
+                num = int(numberOfComponents[name])
+                newitems = []
+                for i in range(len(items) // num):
+                    newitems.append([i for i in items[i * num: i * num + num]])
+                items = newitems
+                # sort the items: we have either vertex or cell data
+                if name in pointDataArrays:
+                    sortedItems = [j for (i, j) in sorted(zip(vertexArray, items), key=itemgetter(0))]
+                elif name in cellDataArrays or name == "types":
+                    sortedItems = [j for (i, j) in sorted(zip(cellArray, items), key=itemgetter(0))]
+                elif name == "offsets":
+                    sortedItems = []
+                    counter = 0
+                    for cell in sorted(cellArray):
+                        counter += len(cell)
+                        sortedItems.append([str(counter)])
+                elif name == "Coordinates":
+                    sortedItems = sorted(vertexArray)
+                elif name == "connectivity":
+                    sortedItems = sorted(cellArray)
+
+                # convert the sorted arrays to a xml text
+                dataArrays[name] = ""
+                for i in sortedItems:
+                    for j in i:
+                        dataArrays[name] += str(j) + " "
+
+            # do the replacement in the actual elements
+            for dataArray in root.findall(".//DataArray"):
+                dataArray.text = dataArrays[dataArray.attrib["Name"]]
+
+    return (root1, root2)
+
+
+# main program if called as script return appropriate error codes
+if __name__ == "__main__":
+    # handle arguments and print help message
+    parser = argparse.ArgumentParser(description='Fuzzy compare of two VTK\
+        (Visualization Toolkit) files. The files are accepted if for every\
+        value the difference is below the absolute error or below the\
+        relative error or below both.')
+    parser.add_argument('vtk_file_1', type=str, help='first file to compare')
+    parser.add_argument('vtk_file_2', type=str, help='second file to compare')
+    parser.add_argument('-r', '--relative', type=float, default=1e-2, help='maximum relative error (default=1e-2)')
+    parser.add_argument('-a', '--absolute', type=float, default=1.5e-7, help='maximum absolute error (default=1.5e-7)')
+    parser.add_argument('-v', '--verbose', type=bool, default=True, help='verbosity of the script')
+    args = vars(parser.parse_args())
+
+    sys.exit(compare_vtk(args["vtk_file_1"], args["vtk_file_2"], args["absolute"], args["relative"], args["verbose"]))
diff --git a/bin/testing/runtest.py b/bin/testing/runtest.py
new file mode 100644
index 0000000000000000000000000000000000000000..c09d586537f50f07ff614a17f3a4f4e43f8872b9
--- /dev/null
+++ b/bin/testing/runtest.py
@@ -0,0 +1,75 @@
+import argparse
+import os, sys
+import subprocess
+import json
+from fuzzycomparevtu import compare_vtk
+
+# parse arguments
+parser = argparse.ArgumentParser()
+parser.add_argument('-c', '--command', nargs=1, help='The executable and optional arguments as a single string', required=True)
+parser.add_argument('-s', '--script', nargs=1, help="The comparison script. [fuzzy, exact, <path_to_script>] where the script takes two vtu files as arguments.")
+parser.add_argument('-f', '--files', nargs='+', help="Pairs of reference and vtu file names. Usage: '[-f ref1 vtu1 [[ref2] [vtu2] ...]]'")
+parser.add_argument('-r', '--relative', type=float, default=1e-2, help='maximum relative error (default=1e-2) when using fuzzy comparison')
+parser.add_argument('-a', '--absolute', type=float, default=1.5e-7, help='maximum absolute error (default=1.5e-7) when using fuzzy comparison')
+parser.add_argument('-z', '--zeroThreshold', type=json.loads, default='{}', help='Thresholds for treating numbers as zero for a parameter as a python dict e.g. {"vel":1e-7,"delP":1.0}')
+args = vars(parser.parse_args())
+
+# check parameters
+if args['script']:
+    if len(args['files'])%2 != 0 or not args['files']:
+        sys.stderr.write("The files have to be pairs of vtu and reference files. Usage '-f [ref1] [vtu1] [[ref2] [vtu2] ...]'")
+        parser.print_help()
+        sys.exit(1)
+    for i in range(0, len(args['files'])//2):
+        # delete the vtu files to compare
+        ref_dir = os.path.dirname(os.path.abspath(__file__)).rstrip("bin") + "test/references"
+        if os.path.dirname(args['files'][(i*2)+1]) == ref_dir:
+            sys.stderr.write("Tried to delete a reference solution. Specify reference file first, then the VTU file. Usage: '[-f ref1 vtu1 [[ref2] [vtu2] ...]]'")
+            sys.exit(1)
+        subprocess.call(['rm', '-fv', args['files'][(i*2)+1]])
+
+# run the test
+res = 1
+try:
+    res = subprocess.call(args['command'][0].split())
+except OSError as e:
+    print(args['command'][0].split())
+    print("OSError: Command not found. Most likely the executable specified doesn't exist.")
+    sys.exit(1)
+if res:
+    sys.exit(res)
+
+# run the comparison
+if args['script']:
+    # exact comparison?
+    if args['script'] == ['exact']:
+        return_code = 0
+        for i in range(0, len(args['files'])//2):
+            print("\nExact comparison...")
+            result = subprocess.call(['diff', args['files'][i*2], args['files'][(i*2)+1]])
+            if result:
+                return_code = 1
+        sys.exit(return_code)
+
+    # fuzzy comparison?
+    elif args['script'] == ["fuzzy"] or args['script'] == [os.path.dirname(os.path.abspath(__file__)) + "/fuzzycomparevtu.py"]:
+        return_code = 0
+        for i in range(0, len(args['files'])//2):
+            print("\nFuzzy comparison...")
+            result = compare_vtk(args['files'][i*2], args['files'][(i*2)+1], relative=args['relative'], absolute=args['absolute'], zeroValueThreshold=args['zeroThreshold'])
+            if result:
+                return_code = 1
+        sys.exit(return_code)
+
+    # other script?
+    else:
+        return_code = 0
+        for i in range(0, len(args['files'])//2):
+            print("\n{} comparison...".format(args['script']))
+            result = subprocess.call(args['script'], args['files'][i*2], args['files'][(i*2)+1])
+            if result:
+                return_code = 1
+        sys.exit(return_code)
+
+# everything is fine
+sys.exit(0)
diff --git a/test/common/generalproblem/CMakeLists.txt b/test/common/generalproblem/CMakeLists.txt
index 6b0fe24d07fd73ae8c8c4516807b6d31a9466100..c4bd5b8735d6d9ddf2a9d1ea91e9d3f39669753d 100644
--- a/test/common/generalproblem/CMakeLists.txt
+++ b/test/common/generalproblem/CMakeLists.txt
@@ -1,21 +1,21 @@
 add_input_file_links()
 
 add_dumux_test(test_general_box test_general test_generalproblem2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/generallens_box-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/generallens_box-00003.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_general -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_generalproblem2p_reference.input -ModelType box")
 
 add_dumux_test(test_general_cc test_general test_generalproblem2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/generallens_cc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/generallens_cc-00003.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_general -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_generalproblem2p_reference.input -ModelType cc")
 
 add_dumux_test(test_general_dec test_general test_generalproblem2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/generallens_sequential-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/generallens_sequential-00003.vtu
diff --git a/test/freeflow/navierstokes/CMakeLists.txt b/test/freeflow/navierstokes/CMakeLists.txt
index 4650a035a75e735a0c87a5eb79407f4dd8754438..f73915e140e66ce88170915a697235366ba719b9 100644
--- a/test/freeflow/navierstokes/CMakeLists.txt
+++ b/test/freeflow/navierstokes/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_navierstokes test_navierstokes test_navierstokes.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_navierstokes"
                   --files ${CMAKE_SOURCE_DIR}/test/references/navierstokes-reference.vtu
diff --git a/test/freeflow/stokes/CMakeLists.txt b/test/freeflow/stokes/CMakeLists.txt
index c7793060b6515e06345c344fcd251f58c4272cfa..39814283406d1a24a72d8f592b5ce2be6c25b6a4 100644
--- a/test/freeflow/stokes/CMakeLists.txt
+++ b/test/freeflow/stokes/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_stokes test_stokes test_stokes.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_stokes"
                   --files ${CMAKE_SOURCE_DIR}/test/references/stokes-reference.vtu
diff --git a/test/freeflow/stokes2c/CMakeLists.txt b/test/freeflow/stokes2c/CMakeLists.txt
index de5e38db19169a8a26520566d07faf2dfe961afa..bfae716453a9627895e9cdf42103a774d1bb9bec 100644
--- a/test/freeflow/stokes2c/CMakeLists.txt
+++ b/test/freeflow/stokes2c/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_stokes2c test_stokes2c test_stokes2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_stokes2c"
                   --files ${CMAKE_SOURCE_DIR}/test/references/stokes2c-reference.vtu
@@ -9,7 +9,7 @@ add_dumux_test(test_stokes2c test_stokes2c test_stokes2c.cc
                   --zeroThreshold {"v":1e-9})
 
 add_dumux_test(test_stokes2c_diffusion test_stokes2c test_stokes2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_stokes2c -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_stokes2c_diffusion.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/stokes2c_diffusion-reference.vtu
diff --git a/test/freeflow/stokes2cni/CMakeLists.txt b/test/freeflow/stokes2cni/CMakeLists.txt
index b314bf4d8a0d752a378481e26cce21009500988d..b4d6dd22b424d15bbeb266eab507bbd70ed42bd3 100644
--- a/test/freeflow/stokes2cni/CMakeLists.txt
+++ b/test/freeflow/stokes2cni/CMakeLists.txt
@@ -1,14 +1,14 @@
 add_input_file_links()
 
 add_dumux_test(test_stokes2cni test_stokes2cni test_stokes2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_stokes2cni"
                   --files ${CMAKE_SOURCE_DIR}/test/references/stokes2cni-reference.vtu
                           ${CMAKE_CURRENT_BINARY_DIR}/stokes2cni-00008.vtu)
 
 add_dumux_test(test_stokes2cni_conduction test_stokes2cni test_stokes2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_stokes2cni -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_stokes2cni_conduction.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/stokes2cni_conduction-reference.vtu
diff --git a/test/freeflow/zeroeq/CMakeLists.txt b/test/freeflow/zeroeq/CMakeLists.txt
index 6218b18b558dcf0027f6f9108654abbf96e732bf..4112470482308e6aa5ff304580e4126a551463b4 100644
--- a/test/freeflow/zeroeq/CMakeLists.txt
+++ b/test/freeflow/zeroeq/CMakeLists.txt
@@ -1,14 +1,14 @@
 add_input_file_links()
 
 add_dumux_test(test_zeroeq test_zeroeq test_zeroeq.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_zeroeq"
                   --files ${CMAKE_SOURCE_DIR}/test/references/zeroeq-reference.vtu
                           ${CMAKE_CURRENT_BINARY_DIR}/zeroeq-00006.vtu)
 
 add_dumux_test(test_zeroeq_channel test_zeroeq_channel test_zeroeq_channel.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_zeroeq_channel"
                   --files ${CMAKE_SOURCE_DIR}/test/references/zeroeqchannel-reference.vtu
diff --git a/test/freeflow/zeroeq2c/CMakeLists.txt b/test/freeflow/zeroeq2c/CMakeLists.txt
index 4829810d9de0afdd40a6e9dadf73a2190ed40ebf..b636ccc2302bcfc8d4b327c8b0275ae9e6b42b4d 100644
--- a/test/freeflow/zeroeq2c/CMakeLists.txt
+++ b/test/freeflow/zeroeq2c/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_zeroeq2c test_zeroeq2c test_zeroeq2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_zeroeq2c"
                   --files ${CMAKE_SOURCE_DIR}/test/references/zeroeq2c-reference.vtu
diff --git a/test/freeflow/zeroeq2cni/CMakeLists.txt b/test/freeflow/zeroeq2cni/CMakeLists.txt
index 1b40beb9558f1720bd4ec55e365c893e084327e7..36f798df166e44849668a324c1e03f5c59146dad 100644
--- a/test/freeflow/zeroeq2cni/CMakeLists.txt
+++ b/test/freeflow/zeroeq2cni/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_zeroeq2cni test_zeroeq2cni test_zeroeq2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_zeroeq2cni"
                   --files ${CMAKE_SOURCE_DIR}/test/references/zeroeq2cni-reference.vtu
diff --git a/test/geomechanics/el1p2c/CMakeLists.txt b/test/geomechanics/el1p2c/CMakeLists.txt
index 76f99ff74dcedde64ed672f81a14b0083f3772a6..adf114bba0d747ea61005a2b0e7559b34fe02539 100644
--- a/test/geomechanics/el1p2c/CMakeLists.txt
+++ b/test/geomechanics/el1p2c/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_el1p2c test_el1p2c test_el1p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/el1p2c-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/el1p2c-00015.vtu
diff --git a/test/geomechanics/el2p/CMakeLists.txt b/test/geomechanics/el2p/CMakeLists.txt
index ac7e639bb58ce604d586a90775991351a93f0266..79302dc24cacc2c8b49512577bb9af9a839568f2 100644
--- a/test/geomechanics/el2p/CMakeLists.txt
+++ b/test/geomechanics/el2p/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_el2p test_el2p test_el2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/el2p-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/el2p-00048.vtu
@@ -9,7 +9,7 @@ add_dumux_test(test_el2p test_el2p test_el2p.cc
 
 if(MPI_FOUND)
   add_dumux_test(test_el2p_parallel test_el2p test_el2p.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                    --script fuzzy
                    --files ${CMAKE_SOURCE_DIR}/test/references/el2p-parallel-reference.vtu
                            ${CMAKE_CURRENT_BINARY_DIR}/s0004-p0001-el2p-00048.vtu
diff --git a/test/geomechanics/elastic/CMakeLists.txt b/test/geomechanics/elastic/CMakeLists.txt
index 68204759ac04ffce110dcbc25ddcf68554513085..abe53c1dcb18bb595cdc3b4da250182e4ad93ae8 100644
--- a/test/geomechanics/elastic/CMakeLists.txt
+++ b/test/geomechanics/elastic/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_elastic test_elastic test_elastic.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/elasticmatrix-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/elasticmatrix-00002.vtu
diff --git a/test/io/gridcreator/CMakeLists.txt b/test/io/gridcreator/CMakeLists.txt
index d1fdecd02e60c1fdec4ee5deee2c9c5e3b6b19a4..db79c4dd5e9d5b5ef2f9a99acfa41e26f988922a 100644
--- a/test/io/gridcreator/CMakeLists.txt
+++ b/test/io/gridcreator/CMakeLists.txt
@@ -1,5 +1,5 @@
 add_dumux_test(test_gridcreator_gmsh test_gridcreator_gmsh test_gridcreator_gmsh.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_gridcreator_gmsh"
                  --files ${CMAKE_SOURCE_DIR}/test/references/bifurcation-reference.vtu
diff --git a/test/material/fluidmatrixinteractions/2p/CMakeLists.txt b/test/material/fluidmatrixinteractions/2p/CMakeLists.txt
index 82364945463877c32211223fb21fda523500da32..54fdffabecfbf948846e6236f3383e12fcc55f31 100644
--- a/test/material/fluidmatrixinteractions/2p/CMakeLists.txt
+++ b/test/material/fluidmatrixinteractions/2p/CMakeLists.txt
@@ -1,14 +1,14 @@
 add_input_file_links()
 
 add_dumux_test(test_thermalconductivityjohansen test_thermalconductivityjohansen test_thermalconductivityjohansen.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script exact
                  --files ${CMAKE_SOURCE_DIR}/test/references/thermalconductivityjohansen-reference.dat
                          ${CMAKE_CURRENT_BINARY_DIR}/johansen_lambda_eff.dat
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_thermalconductivityjohansen")
 
 add_dumux_test(test_thermalconductivitysomerton test_thermalconductivitysomerton test_thermalconductivitysomerton.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script exact
                  --files ${CMAKE_SOURCE_DIR}/test/references/thermalconductivitysomerton-reference.dat
                          ${CMAKE_CURRENT_BINARY_DIR}/somerton_lambda_eff.dat
diff --git a/test/material/fluidmatrixinteractions/CMakeLists.txt b/test/material/fluidmatrixinteractions/CMakeLists.txt
index 88c948f3ba96c6e557c92460fe37a7d977bf7068..b8d2e9804ab554c3016c23e2afd84a4d9d6e126f 100644
--- a/test/material/fluidmatrixinteractions/CMakeLists.txt
+++ b/test/material/fluidmatrixinteractions/CMakeLists.txt
@@ -3,14 +3,14 @@ add_subdirectory("2p")
 add_input_file_links()
 
 add_dumux_test(test_effectivediffusivitymillingtonquirk test_effectivediffusivitymillingtonquirk test_effectivediffusivitymillingtonquirk.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script exact
                  --files ${CMAKE_SOURCE_DIR}/test/references/effectivediffusivitymillingtonquirk-reference.dat
                          ${CMAKE_CURRENT_BINARY_DIR}/millingtonquirk_d_eff.dat
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_effectivediffusivitymillingtonquirk")
 
 add_dumux_test(test_effectivediffusivityconstanttau test_effectivediffusivityconstanttau test_effectivediffusivityconstanttau.cc
-              python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+              python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script exact
                  --files ${CMAKE_SOURCE_DIR}/test/references/effectivediffusivityconstanttau-reference.dat
                          ${CMAKE_CURRENT_BINARY_DIR}/constanttau_d_eff.dat
diff --git a/test/multidomain/2cnistokes2p2cni/CMakeLists.txt b/test/multidomain/2cnistokes2p2cni/CMakeLists.txt
index 648835335987fe306137088ebcaa81270133b8da..356346c9c37cb5d92055ec0914b136b40bdb8625 100644
--- a/test/multidomain/2cnistokes2p2cni/CMakeLists.txt
+++ b/test/multidomain/2cnistokes2p2cni/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_2cnistokes2p2cni test_2cnistokes2p2cni test_2cnistokes2p2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_2cnistokes2p2cni -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_2cnistokes2p2cni_reference.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/2cnistokes2p2cni-ff-reference.vtu
@@ -11,7 +11,7 @@ add_dumux_test(test_2cnistokes2p2cni test_2cnistokes2p2cni test_2cnistokes2p2cni
                   --zeroThreshold {"v":1e-7,"velocityN_0":5e-11,"velocityW_0":5e-10,"velocityW_1":5e-9})
 
 add_dumux_test(test_2cnistokes2p2cni_boundarylayer test_2cnistokes2p2cni test_2cnistokes2p2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_2cnistokes2p2cni -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_2cnistokes2p2cni_boundarylayer.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/2cnistokes2p2cniboundarylayer-ff-reference.vtu
diff --git a/test/multidomain/2cnizeroeq2p2cni/CMakeLists.txt b/test/multidomain/2cnizeroeq2p2cni/CMakeLists.txt
index edc681752917244f838995bbf95e79a1c2a9f554..450d84f3dd69d288ebaf335c0cfd283a78fd8550 100644
--- a/test/multidomain/2cnizeroeq2p2cni/CMakeLists.txt
+++ b/test/multidomain/2cnizeroeq2p2cni/CMakeLists.txt
@@ -3,7 +3,7 @@ add_input_file_links()
 dune_symlink_to_source_files(FILES evaporationRates.gp)
 
 add_dumux_test(test_2cnizeroeq2p2cni test_2cnizeroeq2p2cni test_2cnizeroeq2p2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_2cnizeroeq2p2cni -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_2cnizeroeq2p2cni_reference.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/2cnizeroeq2p2cni-ff-reference.vtu
diff --git a/test/multidomain/2cstokes2p2c/CMakeLists.txt b/test/multidomain/2cstokes2p2c/CMakeLists.txt
index 7c10b93f435308944edaf124206235f87ac408e3..d9d82ca2f551e604a4e840deb5890790225fb7d4 100644
--- a/test/multidomain/2cstokes2p2c/CMakeLists.txt
+++ b/test/multidomain/2cstokes2p2c/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_2cstokes2p2c test_2cstokes2p2c test_2cstokes2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_2cstokes2p2c -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_2cstokes2p2c_reference.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/2cstokes2p2c-ff-reference.vtu
diff --git a/test/multidomain/2czeroeq2p2c/CMakeLists.txt b/test/multidomain/2czeroeq2p2c/CMakeLists.txt
index 52baac1b25d94f51a15dfe849506cb854f6b0f22..1aed4df677354277691009e2085d5fceb5ed1c5f 100644
--- a/test/multidomain/2czeroeq2p2c/CMakeLists.txt
+++ b/test/multidomain/2czeroeq2p2c/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_2czeroeq2p2c test_2czeroeq2p2c test_2czeroeq2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                   --script fuzzy
                   --command "${CMAKE_CURRENT_BINARY_DIR}/test_2czeroeq2p2c -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_2czeroeq2p2c_reference.input"
                   --files ${CMAKE_SOURCE_DIR}/test/references/2czeroeq2p2c-ff-reference.vtu
diff --git a/test/porousmediumflow/1p/implicit/CMakeLists.txt b/test/porousmediumflow/1p/implicit/CMakeLists.txt
index 0fbe8d09be5a45107ddcd4c5b64bf988561ebe98..4d46c9d05cc58a49c82cfad4858f7c8cdeb13db1 100644
--- a/test/porousmediumflow/1p/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/1p/implicit/CMakeLists.txt
@@ -5,28 +5,28 @@ add_gstat_file_links()
 
 # isothermal tests
 add_dumux_test(test_box1p test_box1p test_box1p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestbox-00002.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box1p")
 
 add_dumux_test(test_box1pwithamg test_box1pwithamg test_box1pwithamg.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestboxwithamg-00002.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box1pwithamg")
 
 add_dumux_test(test_cc1p test_cc1p test_cc1p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestcc-00002.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc1p")
 
 add_dumux_test(test_cc1pwithamg test_cc1pwithamg test_cc1pwithamg.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestccwithamg-00002.vtu
@@ -37,7 +37,7 @@ add_dumux_test(test_cc1pwithgstat test_cc1pwithgstat test_cc1pwithgstat.cc
 
 # non-isothermal tests
 add_dumux_test(test_box1pniconduction test_box1pniconduction test_box1pniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1pniboxconduction-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/box1pniconduction-00007.vtu
@@ -45,7 +45,7 @@ add_dumux_test(test_box1pniconduction test_box1pniconduction test_box1pniconduct
                  --zeroThreshold {"velocity":1e-8})
 
 add_dumux_test(test_box1pniconvection test_box1pniconvection test_box1pniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1pniboxconvection-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/box1pniconvection-00011.vtu
@@ -53,7 +53,7 @@ add_dumux_test(test_box1pniconvection test_box1pniconvection test_box1pniconvect
                  --zeroThreshold {"velocity":1e-16})
 
 add_dumux_test(test_cc1pniconduction test_cc1pniconduction test_cc1pniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1pniccconduction-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc1pniconduction-00007.vtu
@@ -61,7 +61,7 @@ add_dumux_test(test_cc1pniconduction test_cc1pniconduction test_cc1pniconduction
                  --zeroThreshold {"velocity":1e-8})
 
 add_dumux_test(test_cc1pniconvection test_cc1pniconvection test_cc1pniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1pniccconvection-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc1pniconvection-00011.vtu
@@ -69,28 +69,28 @@ add_dumux_test(test_cc1pniconvection test_cc1pniconvection test_cc1pniconvection
 
 # dim < dimWorld tests with foamgrid
 add_dumux_test(test_box1p1d3d test_box1p1d3d test_box1p1d3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestbox1d3d-reference.vtp
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestbox1d3d-00002.vtp
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box1p1d3d")
 
 add_dumux_test(test_box1p2d3d test_box1p2d3d test_box1p2d3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestbox2d3d-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestbox2d3d-00002.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box1p2d3d")
 
 add_dumux_test(test_cc1p1d3d test_cc1p1d3d test_cc1p1d3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestcc1d3d-reference.vtp
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestcc1d3d-00002.vtp
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc1p1d3d")
 
 add_dumux_test(test_cc1p2d3d test_cc1p2d3d test_cc1p2d3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1ptestcc2d3d-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1ptestcc2d3d-00002.vtu
diff --git a/test/porousmediumflow/1p/implicit/pointsources/CMakeLists.txt b/test/porousmediumflow/1p/implicit/pointsources/CMakeLists.txt
index e16c582608adb7873d3f66005653671cf688b941..1a1516af9866bb8b136fea6415420fda93ded963 100644
--- a/test/porousmediumflow/1p/implicit/pointsources/CMakeLists.txt
+++ b/test/porousmediumflow/1p/implicit/pointsources/CMakeLists.txt
@@ -1,21 +1,21 @@
 add_input_file_links()
 
 add_dumux_test(test_cc1p_pointsources test_cc1p_pointsources test_cc1p_pointsources.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1psingularitycc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1psingularitycc-00002.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc1p_pointsources")
 
 add_dumux_test(test_cc1p_pointsources_timedependent test_cc1p_pointsources_timedependent test_cc1p_pointsources_timedependent.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1psingularitycctimedependent-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1psingularitycctimedependent-00004.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc1p_pointsources_timedependent -ParameterFile test_cc1p_pointsources.input -TimeManager.TEnd 4 -Problem.Name 1psingularitycctimedependent")
 
 add_dumux_test(test_box1p_pointsources test_box1p_pointsources test_box1p_pointsources.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1psingularitybox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/1psingularitybox-00002.vtu
diff --git a/test/porousmediumflow/1p/sequential/CMakeLists.txt b/test/porousmediumflow/1p/sequential/CMakeLists.txt
index b2aa2a5ce2c328a933e77f3affa1b465242deede..954c7b4b578c4487e46660fc5864041fe0f7c7a4 100644
--- a/test/porousmediumflow/1p/sequential/CMakeLists.txt
+++ b/test/porousmediumflow/1p/sequential/CMakeLists.txt
@@ -1,21 +1,21 @@
 add_input_file_links()
 
 add_dumux_test(test_dec1p test_dec1p test_1p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_1p-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_1p-00001.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_dec1p -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_1p.input")
 
 add_dumux_test(test_diffusion test_diffusion test_diffusion.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/diffusion-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/mimeticdiffusion-00001.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_diffusion 3")
 
 add_dumux_test(test_diffusion3d test_diffusion3d test_diffusion3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_diffusion3d_fv-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_diffusion3d_fv-00001.vtu
diff --git a/test/porousmediumflow/1p2c/implicit/CMakeLists.txt b/test/porousmediumflow/1p2c/implicit/CMakeLists.txt
index 98fb9ec261ca44c4601ac37b3d522bb9a3cf5d2e..206ec0d034df9ce96c5a0192ce249c13a6661827 100644
--- a/test/porousmediumflow/1p2c/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/1p2c/implicit/CMakeLists.txt
@@ -2,7 +2,7 @@ add_input_file_links()
 
 # isothermal tests
 add_dumux_test(test_box1p2c test_box1p2c test_box1p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/outflowbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/outflowbox-00010.vtu
@@ -10,7 +10,7 @@ add_dumux_test(test_box1p2c test_box1p2c test_box1p2c.cc
                  --zeroThreshold {"velocity":5e-16})
 
 add_dumux_test(test_cc1p2c test_cc1p2c test_cc1p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/outflowcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/outflowcc-00010.vtu
@@ -19,7 +19,7 @@ add_dumux_test(test_cc1p2c test_cc1p2c test_cc1p2c.cc
 
 # non-isothermal tests
 add_dumux_test(test_box1p2cniconduction test_box1p2cniconduction test_box1p2cniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1p2cniboxconduction-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/box1p2cniconduction-00007.vtu
@@ -27,7 +27,7 @@ add_dumux_test(test_box1p2cniconduction test_box1p2cniconduction test_box1p2cnic
                  --zeroThreshold {"velocity":1e-8})
 
 add_dumux_test(test_box1p2cniconvection test_box1p2cniconvection test_box1p2cniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1p2cniboxconvection-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/box1p2cniconvection-00011.vtu
@@ -35,7 +35,7 @@ add_dumux_test(test_box1p2cniconvection test_box1p2cniconvection test_box1p2cnic
                  --zeroThreshold {"velocity":1e-16})
 
 add_dumux_test(test_cc1p2cniconduction test_cc1p2cniconduction test_cc1p2cniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1p2cniccconduction-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc1p2cniconduction-00007.vtu
@@ -43,7 +43,7 @@ add_dumux_test(test_cc1p2cniconduction test_cc1p2cniconduction test_cc1p2cnicond
                  --zeroThreshold {"velocity":1e-8})
 
 add_dumux_test(test_cc1p2cniconvection test_cc1p2cniconvection test_cc1p2cniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/1p2cniccconvection-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc1p2cniconvection-00011.vtu
diff --git a/test/porousmediumflow/2p/implicit/CMakeLists.txt b/test/porousmediumflow/2p/implicit/CMakeLists.txt
index cc1a2957fb50e9704857be0abb84ec5ddb9277d7..cee8107ed4883d20912fb6682b2cfe0f9409bfb3 100644
--- a/test/porousmediumflow/2p/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2p/implicit/CMakeLists.txt
@@ -3,28 +3,28 @@ add_input_file_links()
 
 # isothermal tests
 add_dumux_test(test_box2p test_box2p test_box2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/lensbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/lensbox-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2p")
 
 add_dumux_test(test_cc2p test_cc2p test_cc2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/lenscc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/lenscc-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc2p")
 
 add_dumux_test(test_ccadaptive2p test_ccadaptive2p test_ccadaptive2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/lensccadaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/lensccadaptive-00018.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_ccadaptive2p")
 
 add_dumux_test(test_generalizeddirichlet test_generalizeddirichlet test_generalizeddirichlet.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/generalizeddirichlet-reference.vtp
                          ${CMAKE_CURRENT_BINARY_DIR}/generalizeddirichlet-00035.vtp
@@ -32,7 +32,7 @@ add_dumux_test(test_generalizeddirichlet test_generalizeddirichlet test_generali
 
 if(HAVE_DUNE_CORNERPOINT)
 add_dumux_test(test_cc2pcornerpoint test_cc2pcornerpoint test_cc2pcornerpoint.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/cc2pcornerpoint-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc2pcornerpoint-00006.vtu
@@ -42,14 +42,14 @@ endif()
 # non-isothermal tests
 if(HAVE_UG)
 add_dumux_test(test_box2pni test_box2pni test_box2pni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injection2pnibox-simplex-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injection2pnibox-00008.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2pni -Grid.CellType Simplex")
 else()
 add_dumux_test(test_box2pni test_box2pni test_box2pni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injection2pnibox-cube-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injection2pnibox-00008.vtu
@@ -58,14 +58,14 @@ endif()
 
 if(HAVE_UG)
 add_dumux_test(test_cc2pni test_cc2pni test_cc2pni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injection2pnicc-simplex-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injection2pnicc-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc2pni -Grid.CellType Simplex")
 else()
 add_dumux_test(test_cc2pni test_cc2pni test_cc2pni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injection2pnicc-cube-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injection2pnicc-00009.vtu
diff --git a/test/porousmediumflow/2p/implicit/pointsources/CMakeLists.txt b/test/porousmediumflow/2p/implicit/pointsources/CMakeLists.txt
index b81d95e734d8fe8e4c9ac7bf92aeb42ebae95370..dc1b0dfa2c83812e9393bf6837cd571ba3264a13 100644
--- a/test/porousmediumflow/2p/implicit/pointsources/CMakeLists.txt
+++ b/test/porousmediumflow/2p/implicit/pointsources/CMakeLists.txt
@@ -1,5 +1,5 @@
 add_dumux_test(test_ccadaptive2ppointsource test_ccadaptive2ppointsource test_ccadaptive2ppointsource.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/lensccadaptivepointsource-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/lensccadaptive-00012.vtu
diff --git a/test/porousmediumflow/2p/sequential/CMakeLists.txt b/test/porousmediumflow/2p/sequential/CMakeLists.txt
index 6d17d535f9c3c55be4186517615c0298fb1e3a4c..fa297c85e10f89e1bb744038d19fbae3e3583a81 100644
--- a/test/porousmediumflow/2p/sequential/CMakeLists.txt
+++ b/test/porousmediumflow/2p/sequential/CMakeLists.txt
@@ -1,21 +1,21 @@
 add_input_file_links()
 
 add_dumux_test(test_impes test_impes test_impes.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_impes-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_impes-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_impes")
 
 add_dumux_test(test_impesadaptive test_impesadaptive test_impesadaptive.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_2padaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_2padaptive-00007.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_impesadaptive")
 
 add_dumux_test(test_impesadaptiverestart test_impesadaptiverestart test_impesadaptiverestart.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_2padaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_2padaptive-00007.vtu
@@ -26,14 +26,14 @@ set_tests_properties(test_impesadaptiverestart PROPERTIES DEPENDS test_impesadap
 
 if(MPI_FOUND)
   add_dumux_test(test_impeswithamg test_impeswithamg test_impeswithamg.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                    --script fuzzy
                    --files ${CMAKE_SOURCE_DIR}/test/references/test_impes-reference-parallel.vtu
                            ${CMAKE_CURRENT_BINARY_DIR}/s0002-p0001-test_impeswithamg-00094.vtu
                    --command "${MPIEXEC} -np 2 ${CMAKE_CURRENT_BINARY_DIR}/test_impeswithamg -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_impeswithamg.input -TimeManager.TEnd 7e7")
 else()
   add_dumux_test(test_impeswithamg test_impeswithamg test_impeswithamg.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                    --script fuzzy
                    --files ${CMAKE_SOURCE_DIR}/test/references/test_impes-reference.vtu
                            ${CMAKE_CURRENT_BINARY_DIR}/test_impeswithamg-00009.vtu
@@ -41,70 +41,70 @@ else()
 endif()
 
 add_dumux_test(test_transport test_transport test_transport.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_transport-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_transport-00006.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_transport")
 
 add_dumux_test(test_mpfao2p test_mpfa2p test_mpfa2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_mpfao2p-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p-00007.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_mpfa2p.input -ModelType MPFAO")
 
 add_dumux_test(test_mpfal2p test_mpfa2p test_mpfa2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_mpfal2p-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p-00007.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_mpfa2p.input -ModelType MPFAL")
 
 add_dumux_test(test_mpfal2padaptive test_mpfa2p test_mpfa2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_mpfal2padaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p-00007.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_mpfa2p -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_mpfa2p.input -ModelType MPFALAdaptive")
 
 add_dumux_test(test_3d2pfv test_3d2pfv test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pfv-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pfv-00012.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_3d2pfv -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_3d2p.input -Problem.OutputName test_3d2pfv -ModelType FV")
 
 add_dumux_test(test_3d2pfvadaptive test_3d2pfvadaptive test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pfvadaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pfvadaptive-00012.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_3d2pfvadaptive -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_3d2p.input -Problem.OutputName test_3d2pfvadaptive -ModelType FVAdaptive")
 
 add_dumux_test(test_3d2pmimetic test_3d2pmimetic test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pmimetic-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmimetic-00012.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmimetic -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_3d2p.input -Problem.OutputName test_3d2pmimetic -ModelType Mimetic")
 
 add_dumux_test(test_3d2pmimeticadaptive test_3d2pmimeticadaptive test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pmimeticadaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmimeticadaptive-00012.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmimeticadaptive -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_3d2p.input -Problem.OutputName test_3d2pmimeticadaptive -ModelType MimeticAdaptive")
 
 add_dumux_test(test_3d2pmpfal test_3d2pmpfal test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pmpfal-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmpfal-00012.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmpfal -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_3d2p.input -Problem.OutputName test_3d2pmpfal -ModelType MPFAL")
 
 add_dumux_test(test_3d2pmpfaladaptive test_3d2pmpfaladaptive test_3d2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/test_3d2pmpfaladaptive-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_3d2pmpfaladaptive-00012.vtu
diff --git a/test/porousmediumflow/2p2c/implicit/CMakeLists.txt b/test/porousmediumflow/2p2c/implicit/CMakeLists.txt
index a4a8d7568dfffb906206590ae6ba81833af85cc5..3ca817489cb8246aac25c5e29143004ae6f4c8b1 100644
--- a/test/porousmediumflow/2p2c/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2p2c/implicit/CMakeLists.txt
@@ -2,14 +2,14 @@ add_input_file_links()
 
 # isothermal tests
 add_dumux_test(test_box2p2c test_box2p2c test_box2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injectionbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injectionbox-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2p2c")
 
 add_dumux_test(test_cc2p2c test_cc2p2c test_cc2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/injectioncc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/injectioncc-00009.vtu
@@ -17,14 +17,14 @@ add_dumux_test(test_cc2p2c test_cc2p2c test_cc2p2c.cc
 
 # non-isothermal tests
 add_dumux_test(test_box2p2cni test_box2p2cni test_box2p2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/waterairbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/waterairbox-00010.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2p2cni -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_box2p2cni_reference.input")
 
 add_dumux_test(test_cc2p2cni test_cc2p2cni test_cc2p2cni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/wateraircc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/wateraircc-00010.vtu
diff --git a/test/porousmediumflow/2p2c/sequential/CMakeLists.txt b/test/porousmediumflow/2p2c/sequential/CMakeLists.txt
index c2cab2be40a18152961f0b8113f95ceed6637b25..c42ab1ffe4e09edfa2604e05937de972e01b9e69 100644
--- a/test/porousmediumflow/2p2c/sequential/CMakeLists.txt
+++ b/test/porousmediumflow/2p2c/sequential/CMakeLists.txt
@@ -1,28 +1,28 @@
 add_input_file_links()
 
 add_dumux_test(test_adaptive2p2c2d test_adaptive2p2c2d test_adaptive2p2c2d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/test_adaptive2p2c2d-reference.vtu
                        ${CMAKE_CURRENT_BINARY_DIR}/test_adaptive2p2c2d-00008.vtu
                --command "${CMAKE_CURRENT_BINARY_DIR}/test_adaptive2p2c2d")
 
 add_dumux_test(test_adaptive2p2c3d test_adaptive2p2c3d test_adaptive2p2c3d.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/test_adaptive2p2c3d-reference.vtu
                        ${CMAKE_CURRENT_BINARY_DIR}/test_adaptive2p2c3d-00012.vtu
                --command "${CMAKE_CURRENT_BINARY_DIR}/test_adaptive2p2c3d")
 
 add_dumux_test(test_dec2p2c test_dec2p2c test_dec2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/test_dec2p2c-reference.vtu
                        ${CMAKE_CURRENT_BINARY_DIR}/test_dec2p2c-00021.vtu
                --command "${CMAKE_CURRENT_BINARY_DIR}/test_dec2p2c")
 
 add_dumux_test(test_multiphysics2p2c test_multiphysics2p2c test_multiphysics2p2c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/test_multiphysics2p2c-reference.vtu
                        ${CMAKE_CURRENT_BINARY_DIR}/test_multiphysics2p2c-00021.vtu
diff --git a/test/porousmediumflow/2pdfm/implicit/CMakeLists.txt b/test/porousmediumflow/2pdfm/implicit/CMakeLists.txt
index 96baf723a20780a181df425f47997bc26cb9c700..365142db0f1061a308a101083db2636b0d02eae0 100644
--- a/test/porousmediumflow/2pdfm/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2pdfm/implicit/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_2pdfm test_2pdfm test_2pdfm.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/2pdfm-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/2pdfm-00011.vtu
diff --git a/test/porousmediumflow/2pminc/implicit/CMakeLists.txt b/test/porousmediumflow/2pminc/implicit/CMakeLists.txt
index f3bbd15fa70dce483533e87639a0332572c51e77..a19a09f3adf9a517ce399cca09c5a35cd1f3aeda 100644
--- a/test/porousmediumflow/2pminc/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2pminc/implicit/CMakeLists.txt
@@ -1,7 +1,7 @@
 add_input_file_links()
 
 add_dumux_test(test_box2pmincvol test_box2pminc test_box2pminc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/box2pmincvol-reference.vtu
                ${CMAKE_CURRENT_BINARY_DIR}/box2pmincvol-00027.vtu
@@ -9,7 +9,7 @@ add_dumux_test(test_box2pmincvol test_box2pminc test_box2pminc.cc
                )
 
 add_dumux_test(test_box2pmincdist test_box2pminc test_box2pminc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                --script fuzzy
                --files ${CMAKE_SOURCE_DIR}/test/references/box2pmincdist-reference.vtu
                ${CMAKE_CURRENT_BINARY_DIR}/box2pmincdist-00029.vtu
diff --git a/test/porousmediumflow/2pnc/implicit/CMakeLists.txt b/test/porousmediumflow/2pnc/implicit/CMakeLists.txt
index 006dd4d0f239b0b0946813f2b664b21b44a46a92..62b98fcd03733050414762f708b760d580ee09ab 100644
--- a/test/porousmediumflow/2pnc/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2pnc/implicit/CMakeLists.txt
@@ -1,13 +1,13 @@
 # isothermal tests
 add_dumux_test(test_box2pnc test_box2pnc test_box2pnc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/fuelcell2pncbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/fuelcell-box-00016.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2pnc -ParameterFile test_2pnc.input -Problem.Name fuelcell-box")
 
 add_dumux_test(test_cc2pnc test_cc2pnc test_cc2pnc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/fuelcell2pnccc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/fuelcell-cc-00016.vtu
diff --git a/test/porousmediumflow/2pncmin/implicit/CMakeLists.txt b/test/porousmediumflow/2pncmin/implicit/CMakeLists.txt
index 57d159606167bee1e44e5b3ea2067c8f93872c81..abadba04750820d23d4444bdf6c122484ebcdbbc 100644
--- a/test/porousmediumflow/2pncmin/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/2pncmin/implicit/CMakeLists.txt
@@ -1,13 +1,13 @@
 # isothermal tests
 add_dumux_test(test_box2pncmin test_box2pncmin test_box2pncmin.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/saltflushbox2pncmin-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/saltflushbox-00045.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box2pncmin -ParameterFile test_2pncmin.input -Problem.Name saltflushbox")
 
 add_dumux_test(test_cc2pncmin test_cc2pncmin test_cc2pncmin.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/saltflushcc2pncmin-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/saltflushcc-00044.vtu
diff --git a/test/porousmediumflow/3p/implicit/CMakeLists.txt b/test/porousmediumflow/3p/implicit/CMakeLists.txt
index 267c410f12281881e3330d79d843a46c55fb5ef4..2c821855e3f2b13d3e59af754b3d89d9a8ee6c80 100644
--- a/test/porousmediumflow/3p/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/3p/implicit/CMakeLists.txt
@@ -2,14 +2,14 @@ add_input_file_links()
 
 # isothermal tests
 add_dumux_test(test_box3p test_box3p test_box3p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/infiltration3pbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/infiltration3pbox-00009.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box3p")
 
 add_dumux_test(test_cc3p test_cc3p test_cc3p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/infiltration3pcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/infiltration3pcc-00009.vtu
@@ -17,7 +17,7 @@ add_dumux_test(test_cc3p test_cc3p test_cc3p.cc
 
 # non-isothermal tests
 add_dumux_test(test_box3pniconvection test_box3pniconvection test_box3pniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/3pniconvectionbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_box3pniconvection-00011.vtu
@@ -25,7 +25,7 @@ add_dumux_test(test_box3pniconvection test_box3pniconvection test_box3pniconvect
                  --zeroThreshold {"velocityW":1e-16})
 
 add_dumux_test(test_cc3pniconvection test_cc3pniconvection test_cc3pniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/3pniconvectioncc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_cc3pniconvection-00011.vtu
@@ -33,7 +33,7 @@ add_dumux_test(test_cc3pniconvection test_cc3pniconvection test_cc3pniconvection
                  --zeroThreshold {"velocityW":1e-16})
 
 add_dumux_test(test_box3pniconduction test_box3pniconduction test_box3pniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/3pniconductionbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_box3pniconduction-00007.vtu
@@ -41,7 +41,7 @@ add_dumux_test(test_box3pniconduction test_box3pniconduction test_box3pniconduct
                  --zeroThreshold {"velocityW":1e-8})
 
 add_dumux_test(test_cc3pniconduction test_cc3pniconduction test_cc3pniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/3pniconductioncc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_cc3pniconduction-00007.vtu
diff --git a/test/porousmediumflow/3p3c/implicit/CMakeLists.txt b/test/porousmediumflow/3p3c/implicit/CMakeLists.txt
index 5dbbcbc38ecda32bed234b7549f732060c24e264..39a803805bfe9b37342aae011600e6c6058881b0 100644
--- a/test/porousmediumflow/3p3c/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/3p3c/implicit/CMakeLists.txt
@@ -2,14 +2,14 @@ add_input_file_links()
 
 # isothermal tests
 add_dumux_test(test_box3p3c test_box3p3c test_box3p3c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/infiltrationbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/box3p3c-00006.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box3p3c -ParameterFile ${CMAKE_CURRENT_SOURCE_DIR}/test_box3p3c_reference.input")
 
 add_dumux_test(test_cc3p3c test_cc3p3c test_cc3p3c.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/infiltrationcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/cc3p3c-00006.vtu
@@ -17,28 +17,28 @@ add_dumux_test(test_cc3p3c test_cc3p3c test_cc3p3c.cc
 
 # non-isothermal tests
 add_dumux_test(test_box3p3cnicolumnxylol test_box3p3cnicolumnxylol test_box3p3cnicolumnxylol.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/column3p3cnibox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/columnxylolbox-00063.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box3p3cnicolumnxylol")
 
 add_dumux_test(test_cc3p3cnicolumnxylol test_cc3p3cnicolumnxylol test_cc3p3cnicolumnxylol.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/column3p3cnicc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/columnxylolcc-00054.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_cc3p3cnicolumnxylol")
 
 add_dumux_test(test_box3p3cnikuevette test_box3p3cnikuevette test_box3p3cnikuevette.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/kuevette3p3cnibox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/kuevettebox-00005.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_box3p3cnikuevette")
 
 add_dumux_test(test_cc3p3cnikuevette test_cc3p3cnikuevette test_cc3p3cnikuevette.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/kuevette3p3cnicc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/kuevettecc-00005.vtu
diff --git a/test/porousmediumflow/co2/implicit/CMakeLists.txt b/test/porousmediumflow/co2/implicit/CMakeLists.txt
index 34be1f6c3a106cfce7ea7c7222fa82cae6254b04..3d68dd556eaff7484e26d64fb21b08979e348b76 100644
--- a/test/porousmediumflow/co2/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/co2/implicit/CMakeLists.txt
@@ -6,7 +6,7 @@ add_input_file_links()
 # Depending on the order of the elements, the porosity would differ in these cases.
 
 add_dumux_test(test_boxco2 test_boxco2 test_boxco2.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/co2box-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/heterogeneousbox-00020.vtu
@@ -14,14 +14,14 @@ add_dumux_test(test_boxco2 test_boxco2 test_boxco2.cc
                  --zeroThreshold {"porosity":1})
 
 add_dumux_test(test_ccco2 test_ccco2 test_ccco2.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/co2cc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/heterogeneouscc-00019.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_ccco2")
 
 add_dumux_test(test_restartco2 test_boxco2 test_boxco2.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/co2box-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/heterogeneousbox-00020.vtu
@@ -33,7 +33,7 @@ set_tests_properties(test_restartco2 PROPERTIES DEPENDS test_boxco2)
 
 # build target for the CO2 non-isothermal test problem
 add_dumux_test(test_boxco2ni test_boxco2ni test_boxco2ni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/co2nibox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/heterogeneousboxni-00020.vtu
@@ -41,7 +41,7 @@ add_dumux_test(test_boxco2ni test_boxco2ni test_boxco2ni.cc
                  --zeroThreshold {"porosity":1})
 
 add_dumux_test(test_ccco2ni test_ccco2ni test_ccco2ni.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/co2nicc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/heterogeneousccni-00019.vtu
diff --git a/test/porousmediumflow/mpnc/implicit/CMakeLists.txt b/test/porousmediumflow/mpnc/implicit/CMakeLists.txt
index 2e2aa69db5ec524b12e03856fc3e57fb90fdb492..51c67fe33536632a92ca972e07b52bf1db49ea89 100644
--- a/test/porousmediumflow/mpnc/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/mpnc/implicit/CMakeLists.txt
@@ -1,14 +1,14 @@
 add_input_file_links()
 
 add_dumux_test(test_boxmpnc test_boxmpnc test_boxmpnc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/obstaclebox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/obstaclebox-00010.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_boxmpnc")
 
 add_dumux_test(test_ccmpnc test_ccmpnc test_ccmpnc.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/obstaclecc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/obstaclecc-00010.vtu
@@ -16,7 +16,7 @@ add_dumux_test(test_ccmpnc test_ccmpnc test_ccmpnc.cc
 
 # build target for the one-phase Forchheimer test problem
 add_dumux_test(test_forchheimer1p test_forchheimer1p test_forchheimer1p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/forchheimer1p-reference.vtp
                          ${CMAKE_CURRENT_BINARY_DIR}/test_forchheimer1p-00002.vtp
@@ -24,7 +24,7 @@ add_dumux_test(test_forchheimer1p test_forchheimer1p test_forchheimer1p.cc
 
 # build target for the two-phase Forchheimer test problem
 add_dumux_test(test_forchheimer2p test_forchheimer2p test_forchheimer2p.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/forchheimer2p-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_forchheimer2p-00009.vtu
@@ -32,7 +32,7 @@ add_dumux_test(test_forchheimer2p test_forchheimer2p test_forchheimer2p.cc
 
 # build target for the full kinetic test problem
 add_dumux_test(test_boxmpnckinetic test_boxmpnckinetic test_boxmpnckinetic.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/evaporationatmosphere-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/evaporationatmosphere-00006.vtu
@@ -41,7 +41,7 @@ add_dumux_test(test_boxmpnckinetic test_boxmpnckinetic test_boxmpnckinetic.cc
 
 # build target for the energy kinetic test problem, two energy balance equations
 add_dumux_test(test_boxmpncthermalnonequil test_boxmpncthermalnonequil test_boxmpncthermalnonequil.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/combustion-reference.vtp
                          ${CMAKE_CURRENT_BINARY_DIR}/combustion-00078.vtp
diff --git a/test/porousmediumflow/richards/implicit/CMakeLists.txt b/test/porousmediumflow/richards/implicit/CMakeLists.txt
index 52a1384ee19f7a5cf2d398cb23d0a31dfb87f950..b7c17a310ae06891edd1444f27eaa4f4f7a61ea7 100644
--- a/test/porousmediumflow/richards/implicit/CMakeLists.txt
+++ b/test/porousmediumflow/richards/implicit/CMakeLists.txt
@@ -2,7 +2,7 @@ add_input_file_links()
 
 if(MPI_FOUND)
   add_dumux_test(test_boxrichards test_boxrichards test_boxrichards.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                    --script fuzzy
                    --files ${CMAKE_SOURCE_DIR}/test/references/richardslensbox-reference-parallel.vtu
                            ${CMAKE_CURRENT_BINARY_DIR}/s0002-p0000-richardslensbox-00008.vtu
@@ -10,7 +10,7 @@ if(MPI_FOUND)
 else()
 # isothermal tests
   add_dumux_test(test_boxrichards test_boxrichards test_boxrichards.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                    --script fuzzy
                    --files ${CMAKE_SOURCE_DIR}/test/references/richardslensbox-reference.vtu
                            ${CMAKE_CURRENT_BINARY_DIR}/richardslensbox-00008.vtu
@@ -18,7 +18,7 @@ else()
 endif()
 
 add_dumux_test(test_ccrichards test_ccrichards test_ccrichards.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardslenscc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/richardslenscc-00008.vtu
@@ -26,7 +26,7 @@ add_dumux_test(test_ccrichards test_ccrichards test_ccrichards.cc
 
 # comparison to analytical solution - only with cc
 add_dumux_test(test_ccrichardsanalytical test_ccrichardsanalytical test_ccrichardsanalytical.cc
-                 python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+                 python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardsanalyticalcc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/richardsanalyticalcc-00001.vtu
@@ -34,7 +34,7 @@ add_dumux_test(test_ccrichardsanalytical test_ccrichardsanalytical test_ccrichar
 
 # non-isothermal tests
 add_dumux_test(test_boxrichardsniconvection test_boxrichardsniconvection test_boxrichardsniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardsniconvectionbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_boxrichardsniconvection-00011.vtu
@@ -42,14 +42,14 @@ add_dumux_test(test_boxrichardsniconvection test_boxrichardsniconvection test_bo
                  --zeroThreshold {"velocity":1e-16})
 
 add_dumux_test(test_ccrichardsniconvection test_ccrichardsniconvection test_ccrichardsniconvection.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardsniconvectioncc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_ccrichardsniconvection-00011.vtu
                  --command "${CMAKE_CURRENT_BINARY_DIR}/test_ccrichardsniconvection")
 
 add_dumux_test(test_boxrichardsniconduction test_boxrichardsniconduction test_boxrichardsniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardsniconductionbox-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_boxrichardsniconduction-00007.vtu
@@ -57,7 +57,7 @@ add_dumux_test(test_boxrichardsniconduction test_boxrichardsniconduction test_bo
                  --zeroThreshold {"velocity":1e-8})
 
 add_dumux_test(test_ccrichardsniconduction test_ccrichardsniconduction test_ccrichardsniconduction.cc
-               python ${CMAKE_SOURCE_DIR}/bin/runtest.py
+               python ${CMAKE_SOURCE_DIR}/bin/testing/runtest.py
                  --script fuzzy
                  --files ${CMAKE_SOURCE_DIR}/test/references/richardsniconductioncc-reference.vtu
                          ${CMAKE_CURRENT_BINARY_DIR}/test_ccrichardsniconduction-00007.vtu