From 47a18314d131c79a0758486a7736c9cceeba4a76 Mon Sep 17 00:00:00 2001
From: Christoph Grueninger <christoph.grueninger@iws.uni-stuttgart.de>
Date: Fri, 9 May 2014 12:09:20 +0000
Subject: [PATCH] [test_fluidsystems] Add missing qualifier Dumux.

GCC 4.9 complained about it.
(reviewed by martinb)


git-svn-id: svn://svn.iws.uni-stuttgart.de/DUMUX/dumux/trunk@12822 2fb0f335-1f38-0410-981e-8018bf24f1b0
---
 .../fluidsystems/test_fluidsystems.cc         | 44 +++++++++----------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/test/material/fluidsystems/test_fluidsystems.cc b/test/material/fluidsystems/test_fluidsystems.cc
index e29b8ac292..94575563e8 100644
--- a/test/material/fluidsystems/test_fluidsystems.cc
+++ b/test/material/fluidsystems/test_fluidsystems.cc
@@ -62,28 +62,28 @@ int main()
 
         // CompositionalFluidState
         {   Dumux::CompositionalFluidState<Scalar, FluidSystem> fs;
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::CompositionalFluidState: \n"<<collectedExceptions<<"\n";
             }}
 
         // NonEquilibriumFluidState
         {   Dumux::NonEquilibriumFluidState<Scalar, FluidSystem> fs;
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::NonEquilibriumFluidState: \n"<<collectedExceptions<<"\n";
             }}
 
         // ImmiscibleFluidState
         {   Dumux::ImmiscibleFluidState<Scalar, FluidSystem> fs;
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::ImmiscibleFluidState: \n"<<collectedExceptions<<"\n";
             }}
 
         // IsothermalImmiscibleFluidState
         {   Dumux::IsothermalImmiscibleFluidState<Scalar, FluidSystem> fs;
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::IsothermalImmiscibleFluidState: \n"<<collectedExceptions<<"\n";
             }}
@@ -93,21 +93,21 @@ int main()
 
         // TemperatureOverlayFluidState
         {   Dumux::TemperatureOverlayFluidState<Scalar, BaseFluidState> fs(baseFs);
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::TemperatureOverlayFluidState: \n"<<collectedExceptions<<"\n";
             } }
 
         // PressureOverlayFluidState
         {   Dumux::PressureOverlayFluidState<Scalar, BaseFluidState> fs(baseFs);
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::PressureOverlayFluidState: \n"<<collectedExceptions<<"\n";
             }}
 
         // SaturationOverlayFluidState
         {   Dumux::SaturationOverlayFluidState<Scalar, BaseFluidState> fs(baseFs);
-            std::string collectedExceptions = checkFluidState<Scalar>(fs);
+            std::string collectedExceptions = Dumux::checkFluidState<Scalar>(fs);
             if (!collectedExceptions.empty()){
                 std::cout<<"Dumux::SaturationOverlayFluidState: \n"<<collectedExceptions<<"\n";
             }}
@@ -115,63 +115,63 @@ int main()
 
     // H2O -- N2
     {   typedef Dumux::FluidSystems::H2ON2<Scalar, /*enableComplexRelations=*/false> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::FluidSystems::H2ON2<Scalar, /*enableComplexRelations=*/true> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // H2O -- N2 -- liquid phase
     {   typedef Dumux::FluidSystems::H2ON2LiquidPhase<Scalar, /*enableComplexRelations=*/false> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::FluidSystems::H2ON2LiquidPhase<Scalar, /*enableComplexRelations=*/true> FluidSystem;
-         checkFluidSystem<Scalar, FluidSystem>(); }
+         Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // H2O -- Air
     {   typedef Dumux::SimpleH2O<Scalar> H2O;
         const bool enableComplexRelations=false;
         typedef Dumux::FluidSystems::H2OAir<Scalar, H2O, enableComplexRelations> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::SimpleH2O<Scalar> H2O;
         const bool enableComplexRelations=true;
         typedef Dumux::FluidSystems::H2OAir<Scalar, H2O, enableComplexRelations> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::H2O<Scalar> H2O;
         const bool enableComplexRelations=false;
         typedef Dumux::FluidSystems::H2OAir<Scalar, H2O, enableComplexRelations> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::H2O<Scalar> H2O;
         const bool enableComplexRelations=true;
         typedef Dumux::FluidSystems::H2OAir<Scalar, H2O, enableComplexRelations> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // H2O -- Air -- Mesitylene
     {   typedef Dumux::FluidSystems::H2OAirMesitylene<Scalar> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // H2O -- Air -- Xylene
     {   typedef Dumux::FluidSystems::H2OAirXylene<Scalar> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // 2p-immiscible
     {   typedef Dumux::FluidSystems::TwoPImmiscible<Scalar, Liquid, Liquid> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::FluidSystems::TwoPImmiscible<Scalar, Liquid, Gas> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {  typedef Dumux::FluidSystems::TwoPImmiscible<Scalar, Gas, Liquid> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     // 1p
     {   typedef Dumux::FluidSystems::OneP<Scalar, Liquid> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     {   typedef Dumux::FluidSystems::OneP<Scalar, Gas> FluidSystem;
-        checkFluidSystem<Scalar, FluidSystem>(); }
+        Dumux::checkFluidSystem<Scalar, FluidSystem>(); }
 
     return 0;
 }
-- 
GitLab