diff --git a/dumux/multidomain/common/multidomainproblem.hh b/dumux/multidomain/common/multidomainproblem.hh
index a701a5e38bf73961c10d5f6d75b0d104d2535750..d8b8d2f44c1dcf9297e04cac4fde8668561d9c3a 100644
--- a/dumux/multidomain/common/multidomainproblem.hh
+++ b/dumux/multidomain/common/multidomainproblem.hh
@@ -468,7 +468,7 @@ private:
 // definition of the static class member simname_,
 // which is necessary because it is of type string.
 template <class TypeTag>
-std::string MultiDomainProblem<TypeTag>::simname_="simCoupled"; //initialized with default "sim"
+std::string MultiDomainProblem<TypeTag>::simname_ = "simCoupled";
 
 } // namespace Dumux
 
diff --git a/test/common/generalproblem/generallensproblem.hh b/test/common/generalproblem/generallensproblem.hh
index cbcc9e034d934c8699eec25d4a45a4b9490fd1c5..cb56a2809fd189c32bef14d986407806ab0fd876 100644
--- a/test/common/generalproblem/generallensproblem.hh
+++ b/test/common/generalproblem/generallensproblem.hh
@@ -236,7 +236,7 @@ public:
     {
         if (!this->timeManager().willBeFinished())
         this->timeManager().startNextEpisode(500);
-    };
+    }
 
     /*!
      * \brief The problem name.
@@ -266,7 +266,7 @@ public:
     Scalar temperatureAtPos(const GlobalPosition &globalPos) const
     {
         return temperature_;
-    };
+    }
 
     //! Returns the reference pressure for evaluation of constitutive relations
     /*!
diff --git a/test/common/spline/test_spline.cc b/test/common/spline/test_spline.cc
index 7e57d5ba4ab15b3b4552127c36c4a6a078086fd7..cd47bf8ee045b563de0a0ada5f3e4d998e9f1e0a 100644
--- a/test/common/spline/test_spline.cc
+++ b/test/common/spline/test_spline.cc
@@ -41,10 +41,6 @@ gnuplot> plot "spline.csv" using 1:2 w l ti "Curve", \
 
 #include <dune/common/fvector.hh>
 
-#define GCC_VERSION (__GNUC__ * 10000 \
-               + __GNUC_MINOR__ * 100 \
-               + __GNUC_PATCHLEVEL__)
-
 template <class Spline>
 void testCommon(const Spline &sp,
                 const double *x,
@@ -149,7 +145,6 @@ void testAll()
         };
 
 
-#if GCC_VERSION >= 40500
     std::initializer_list<const std::pair<double, double> > pointsInitList =
         {
             {x[0], y[0]},
@@ -158,7 +153,6 @@ void testAll()
             {x[3], y[3]},
             {x[4], y[4]},
         };
-#endif
 
     std::vector<double> xVec;
     std::vector<double> yVec;
@@ -174,9 +168,9 @@ void testAll()
     /////////
 
     // full spline
-    { Dumux::Spline<double, 2> sp(x[0], x[1], y[0], y[1], m0, m1); sp.set(x[0],x[1],y[0],y[1],m0, m1); testFull(sp, x, y, m0, m1); };
-    { Dumux::Spline<double, 2> sp(x, y, m0, m1); sp.setXYArrays(2, x, y, m0, m1); testFull(sp, x, y, m0, m1);  };
-    { Dumux::Spline<double, 2> sp(points, m0, m1); sp.setArrayOfPoints(2, points, m0, m1); testFull(sp, x, y, m0, m1); };
+    { Dumux::Spline<double, 2> sp(x[0], x[1], y[0], y[1], m0, m1); sp.set(x[0],x[1],y[0],y[1],m0, m1); testFull(sp, x, y, m0, m1); }
+    { Dumux::Spline<double, 2> sp(x, y, m0, m1); sp.setXYArrays(2, x, y, m0, m1); testFull(sp, x, y, m0, m1);  }
+    { Dumux::Spline<double, 2> sp(points, m0, m1); sp.setArrayOfPoints(2, points, m0, m1); testFull(sp, x, y, m0, m1); }
 
 
     /////////
@@ -184,41 +178,33 @@ void testAll()
     /////////
 
     // full spline
-    { Dumux::Spline<double, 5> sp(x, y, m0, m1); sp.setXYArrays(5, x, y, m0, m1); testFull(sp, x, y, m0, m1);  };
-    { Dumux::Spline<double, 5> sp; sp.setArrayOfPoints(5, points, m0, m1); testFull(sp, x, y, m0, m1); };
-    { Dumux::Spline<double, 5> sp; sp.setContainerOfPoints(pointVec,m0, m1); testFull(sp, x, y, m0, m1); };
-#if GCC_VERSION >= 40500
-    { Dumux::Spline<double, 5> sp; sp.setContainerOfTuples(pointsInitList, m0, m1); testFull(sp, x, y, m0, m1); };
-#endif
+    { Dumux::Spline<double, 5> sp(x, y, m0, m1); sp.setXYArrays(5, x, y, m0, m1); testFull(sp, x, y, m0, m1);  }
+    { Dumux::Spline<double, 5> sp; sp.setArrayOfPoints(5, points, m0, m1); testFull(sp, x, y, m0, m1); }
+    { Dumux::Spline<double, 5> sp; sp.setContainerOfPoints(pointVec,m0, m1); testFull(sp, x, y, m0, m1); }
+    { Dumux::Spline<double, 5> sp; sp.setContainerOfTuples(pointsInitList, m0, m1); testFull(sp, x, y, m0, m1); }
 
     // natural spline
-    { Dumux::Spline<double, 5> sp(x, y); sp.setXYArrays(5, x, y); testNatural(sp, x, y); };
-    { Dumux::Spline<double, 5> sp; sp.setContainerOfPoints(pointVec); testNatural(sp, x, y); };
-#if GCC_VERSION >= 40500
-    { Dumux::Spline<double, 5> sp; sp.setContainerOfTuples(pointsInitList); testNatural(sp, x, y); };
-#endif
+    { Dumux::Spline<double, 5> sp(x, y); sp.setXYArrays(5, x, y); testNatural(sp, x, y); }
+    { Dumux::Spline<double, 5> sp; sp.setContainerOfPoints(pointVec); testNatural(sp, x, y); }
+    { Dumux::Spline<double, 5> sp; sp.setContainerOfTuples(pointsInitList); testNatural(sp, x, y); }
 
     /////////
     // test variable length splines
     /////////
 
     // full spline
-    { Dumux::Spline<double, -1> sp(5, x, y, m0, m1); sp.setXYArrays(5,x,y,m0, m1); testFull(sp, x, y, m0, m1);  };
-    { Dumux::Spline<double, -1> sp(xVec, yVec, m0, m1); sp.setXYContainers(xVec,yVec,m0, m1); testFull(sp, x, y, m0, m1);  };
-    { Dumux::Spline<double, -1> sp; sp.setArrayOfPoints(5,points,m0, m1); testFull(sp, x, y, m0, m1); };
-    { Dumux::Spline<double, -1> sp; sp.setContainerOfPoints(pointVec,m0, m1); testFull(sp, x, y, m0, m1);  };
-#if GCC_VERSION >= 40500
-    { Dumux::Spline<double, -1> sp; sp.setContainerOfTuples(pointsInitList,m0, m1); testFull(sp, x, y, m0, m1); };
-#endif
+    { Dumux::Spline<double, -1> sp(5, x, y, m0, m1); sp.setXYArrays(5,x,y,m0, m1); testFull(sp, x, y, m0, m1);  }
+    { Dumux::Spline<double, -1> sp(xVec, yVec, m0, m1); sp.setXYContainers(xVec,yVec,m0, m1); testFull(sp, x, y, m0, m1);  }
+    { Dumux::Spline<double, -1> sp; sp.setArrayOfPoints(5,points,m0, m1); testFull(sp, x, y, m0, m1); }
+    { Dumux::Spline<double, -1> sp; sp.setContainerOfPoints(pointVec,m0, m1); testFull(sp, x, y, m0, m1);  }
+    { Dumux::Spline<double, -1> sp; sp.setContainerOfTuples(pointsInitList,m0, m1); testFull(sp, x, y, m0, m1); }
 
     // natural spline
-    { Dumux::Spline<double, -1> sp(5, x, y); sp.setXYArrays(5,x,y); testNatural(sp, x, y);  };
-    { Dumux::Spline<double, -1> sp(xVec, yVec); sp.setXYContainers(xVec,yVec); testNatural(sp, x, y); };
-    { Dumux::Spline<double, -1> sp; sp.setArrayOfPoints(5,points); testNatural(sp, x, y); };
-    { Dumux::Spline<double, -1> sp; sp.setContainerOfPoints(pointVec); testNatural(sp, x, y); };
-#if GCC_VERSION >= 40500
-    { Dumux::Spline<double, -1> sp; sp.setContainerOfTuples(pointsInitList); testNatural(sp, x, y); };
-#endif
+    { Dumux::Spline<double, -1> sp(5, x, y); sp.setXYArrays(5,x,y); testNatural(sp, x, y);  }
+    { Dumux::Spline<double, -1> sp(xVec, yVec); sp.setXYContainers(xVec,yVec); testNatural(sp, x, y); }
+    { Dumux::Spline<double, -1> sp; sp.setArrayOfPoints(5,points); testNatural(sp, x, y); }
+    { Dumux::Spline<double, -1> sp; sp.setContainerOfPoints(pointVec); testNatural(sp, x, y); }
+    { Dumux::Spline<double, -1> sp; sp.setContainerOfTuples(pointsInitList); testNatural(sp, x, y); }
 }
 
 void plot()
diff --git a/test/material/fluidsystems/checkfluidsystem.hh b/test/material/fluidsystems/checkfluidsystem.hh
index e26387395e1bf7a50c08b5afa2badc2e34d8fa82..80b15b7306f8ed6f6fa2c3ef9a8a0cfb10708081 100644
--- a/test/material/fluidsystems/checkfluidsystem.hh
+++ b/test/material/fluidsystems/checkfluidsystem.hh
@@ -383,19 +383,19 @@ void checkFluidSystem()
         paramCache.updateAll(fs);
     } catch (...)
     {
-    };
+    }
     try
     {
         paramCache.updateAll(fs, /*except=*/PC::None);
     } catch (...)
     {
-    };
+    }
     try
     {
         paramCache.updateAll(fs, /*except=*/PC::Temperature | PC::Pressure | PC::Composition);
     } catch (...)
     {
-    };
+    }
     try
     {
         paramCache.updateAllPressures(fs);
@@ -411,43 +411,43 @@ void checkFluidSystem()
             paramCache.updatePhase(fs, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updatePhase(fs, phaseIdx, /*except=*/PC::None);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updatePhase(fs, phaseIdx, /*except=*/PC::Temperature | PC::Pressure | PC::Composition);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updateTemperature(fs, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updatePressure(fs, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updateComposition(fs, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             paramCache.updateSingleMoleFraction(fs, phaseIdx, /*compIdx=*/0);
         } catch (...)
         {
-        };
+        }
     }
 
     // some value to make sure the return values of the fluid system
@@ -468,7 +468,7 @@ void checkFluidSystem()
         } catch (Dune::Exception e)
         {
             std::cout << "\ndensity calculation throws exception:\n" << e.what();
-        };
+        }
 
         fs.allowPressure(true);
         fs.allowDensity(true);
@@ -477,25 +477,25 @@ void checkFluidSystem()
             val = FluidSystem::viscosity(fs, paramCache, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             val = FluidSystem::enthalpy(fs, paramCache, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             val = FluidSystem::heatCapacity(fs, paramCache, phaseIdx);
         } catch (...)
         {
-        };
+        }
         try
         {
             val = FluidSystem::thermalConductivity(fs, paramCache, phaseIdx);
         } catch (...)
         {
-        };
+        }
 
         for (int compIdx = 0; compIdx < numComponents; ++compIdx)
         {
@@ -505,14 +505,14 @@ void checkFluidSystem()
                 val = FluidSystem::fugacityCoefficient(fs, paramCache, phaseIdx, compIdx);
             } catch (...)
             {
-            };
+            }
             fs.allowComposition(true);
             try
             {
                 val = FluidSystem::diffusionCoefficient(fs, paramCache, phaseIdx, compIdx);
             } catch (...)
             {
-            };
+            }
             for (int comp2Idx = 0; comp2Idx < numComponents; ++comp2Idx)
             {
                 try
@@ -520,7 +520,7 @@ void checkFluidSystem()
                     val = FluidSystem::binaryDiffusionCoefficient(fs, paramCache, phaseIdx, compIdx, comp2Idx);
                 } catch (...)
                 {
-                };
+                }
             }
         }
     }