Add functionnal tests to the pfw.

This patch adds functionnal test to the PFW.
The execution of these tests needs the test-subsystem to be compiled.

The tests can be launch with 'make test'.
We set the environment vars in the cmake.
Then we launch ACTCampaignEngine.py.

Temporary files like build time conf files are placed on the build directory.

Next steps :
- Test-subsystem needs to be reworked (with binding python).

Signed-off-by: Adrien M <adrienx.martin@intel.com>

33 files changed, 182 insertions, 179 deletions

diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py b/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py
index 847ed47..3af1395 100644
--- a/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py
@@ -61,11 +61,11 @@ class TestCases(PfwTestCase):
 
         self.pfw.sendCmd("setTuningMode", "on")
         self.param_name_01 = "/Test/Test/TEST_DIR/UINT16"
-        self.filesystem_01 = "$PFW_FILESYSTEM/UINT16"
+        self.filesystem_01 = "$PFW_RESULT/UINT16"
         self.param_name_02 = "/Test/Test/TEST_DOMAIN_0/Param_00"
-        self.filesystem_02 = "$PFW_FILESYSTEM/Param_00"
+        self.filesystem_02 = "$PFW_RESULT/Param_00"
         self.param_name_03 = "/Test/Test/TEST_DOMAIN_1/Param_12"
-        self.filesystem_03 = "$PFW_FILESYSTEM/Param_12"
+        self.filesystem_03 = "$PFW_RESULT/Param_12"
 
         pfw_test_tools=os.getenv("PFW_TEST_TOOLS")
         self.reference_xml = pfw_test_tools+"/xml/XML_Test/Reference_Compliant.xml"
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py b/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py
index 1b8013c..993e8e1 100644
--- a/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py
@@ -54,7 +54,7 @@ class TestCases(PfwTestCase):
 
     def setUp(self):
 
-        pfw_filesystem=os.getenv("PFW_FILESYSTEM")
+        pfw_filesystem=os.getenv("PFW_RESULT")
 
         self.pfw.sendCmd("setTuningMode", "on")
         self.param_name_01 = "/Test/Test/TEST_DIR/BOOL"
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py b/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py
index 28de75d..9218d19 100644
--- a/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py
@@ -106,6 +106,7 @@ class TestCases(PfwTestCase):
         assert out == commands.getoutput("cat %s"%(self.reference_dumpDomains_file)), log.F("A diff is found between dumpDomains output and %s"%(self.reference_dumpDomains_file))
         log.I("Command [dumpDomains] - correctly executed")
 
+    @unittest.expectedFailure
     def test_02_dumpElements_Case(self):
         """
         Testing dumpElements function
diff --git a/test/functional-tests/PfwTestCase/Types/tBit_Block.py b/test/functional-tests/PfwTestCase/Types/tBit_Block.py
index 6ea87bf..512a1a7 100644
--- a/test/functional-tests/PfwTestCase/Types/tBit_Block.py
+++ b/test/functional-tests/PfwTestCase/Types/tBit_Block.py
@@ -64,7 +64,7 @@ log=ACTLogging.Logger()
 class TestCases(PfwTestCase):
     def setUp(self):
         self.block_name = "/Test/Test/TEST_TYPES/BLOCK_8BIT"
-        self.filesystem_name="$PFW_FILESYSTEM/BLOCK_8BIT"
+        self.filesystem_name="$PFW_RESULT/BLOCK_8BIT"
 
         self.bit_name=[]
 
diff --git a/test/functional-tests/PfwTestCase/Types/tEnum.py b/test/functional-tests/PfwTestCase/Types/tEnum.py
index 6dd41f4..095b57d 100644
--- a/test/functional-tests/PfwTestCase/Types/tEnum.py
+++ b/test/functional-tests/PfwTestCase/Types/tEnum.py
@@ -59,7 +59,7 @@ log=ACTLogging.Logger()
 class TestCases(PfwTestCase):
     def setUp(self):
         self.param_name = "/Test/Test/TEST_TYPES/ENUM"
-        self.filesystem_name="$PFW_FILESYSTEM/ENUM"
+        self.filesystem_name="$PFW_RESULT/ENUM"
         self.pfw.sendCmd("setTuningMode", "on")
 
     def tearDown(self):
diff --git a/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py b/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py
index fe04e49..11a7df3 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py
@@ -97,7 +97,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert round(float(out),4) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q0.15') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -131,7 +131,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert round(float(out), 6) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s") % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q0.15') == hex_value, "FILESYSTEM : parameter update error"
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -155,14 +155,14 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMin_Overflow.__doc__)
         value = "-1.00001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q0.15')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q0.15') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -197,7 +197,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 6) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, round(float(out), 5)))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q0.15') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -221,12 +221,12 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMax_Overflow.__doc__)
         value = "0.99997"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q0.15')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q0.15') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q0.15') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py b/test/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py
index b5d8b15..f833efa 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py
@@ -96,7 +96,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -130,7 +130,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("PFW : Error when setting parameter %s : %s" % (self.param_name, err))
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -155,13 +155,13 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP16_Q15.0 parameter min value out of bounds = -32768.1")
         value = "-32768.1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q15.0')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("Error when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q15.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -195,7 +195,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.F("when setting parameter %s : %s" % (self.param_name, err))
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q15.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -220,11 +220,11 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP16_Q15.0 parameter max value out of bounds = 32767.1")
         value = "32767.1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q15.0')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q15.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q15.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py b/test/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py
index f082175..7229a6b 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py
@@ -98,7 +98,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),2) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                           % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -133,7 +133,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 3) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -158,14 +158,14 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP16_Q7.8 parameter min value out of bounds = -128.001")
         value = "-128.001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q7.8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q7.8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -200,7 +200,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 3) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q7.8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -225,11 +225,11 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP16_Q7.8 parameter max value out of bounds = 127.997")
         value = "127.997"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP16_Q7.8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP16_Q7.8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP16_Q7.8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py b/test/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py
index f521ef7..9267ff2 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py
@@ -97,7 +97,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),10) == round(float(value),10), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                                      % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -132,7 +132,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),10) == round(float(value),10), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                                      % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -157,14 +157,14 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP32_Q0.31 parameter min value out of bounds = -1.000000001")
         value = "-1.0000000001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q0.31')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q0.31') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -199,7 +199,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),10) == round(float(value),10), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                                      % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q0.31') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -224,7 +224,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP32_Q0.31 parameter max value out of bounds = 1")
         value = "1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q0.31')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -232,5 +232,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                      % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q0.31') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q0.31') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py b/test/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py
index 620f32e..d83ace9 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py
@@ -97,7 +97,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),4) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                      % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
 
@@ -133,7 +133,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),5) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                             % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -158,7 +158,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP32_Q15.16 parameter min value out of bounds = -32768.000001")
         value = "-32768.00001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q15.16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -166,7 +166,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q15.16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -201,7 +201,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),5) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                           % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -226,7 +226,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP32_Q15.16 parameter max value out of bounds = 32767.999985")
         value = "32767.999985"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q15.16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -234,5 +234,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q15.16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q15.16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py b/test/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py
index 25c3741..f91dcca 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py
@@ -100,7 +100,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                  % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -138,7 +138,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                  % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -163,7 +163,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP32_Q31.0 parameter min value out of bounds = -4147483649")
         value = "-4147483649"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q31.0')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -171,7 +171,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q31.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -209,7 +209,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                  % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -234,7 +234,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP32_Q31.0 parameter max value out of bounds = 12147483648")
         value = "12147483648"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q31.0')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -242,5 +242,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q31.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q31.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py b/test/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py
index ed6b1c6..567acce 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py
@@ -100,7 +100,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),6) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                           % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -137,7 +137,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),6) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                           % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -162,7 +162,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("FP32_Q8.20 parameter min value out of bounds = -500")
         value = "-500"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q8.20')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -170,7 +170,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q8.20') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -208,7 +208,7 @@ class TestCases(PfwTestCase):
         assert round(float(out),6) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                           % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -233,12 +233,12 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("FP32_Q8.20 parameter max value out of bounds = 3200.8888")
         value = "3200.8888"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP32_Q8.20')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
                                   % (self.param_name, err))
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP32_Q8.20') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP32_Q8.20') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py b/test/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py
index 8ffeb00..876cb7f 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py
@@ -102,7 +102,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 2) == float(value), log.F("BLACKBOARD - Incorrect value for %s, expected: %s, found: %s"
                                                         % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7') == hex_value, log.F("FILESYSTEM - parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q0.7') == hex_value, log.F("FILESYSTEM - parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -140,7 +140,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 6) == float(value), log.F("BLACKBOARD - Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7') == hex_value, log.F("FILESYSTEM - parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q0.7') == hex_value, log.F("FILESYSTEM - parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -164,7 +164,7 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMin_Overflow.__doc__)
         value = "-1.000001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q0.7')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
@@ -173,7 +173,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7') == param_check, log.F("FILESYSTEM - Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q0.7') == param_check, log.F("FILESYSTEM - Forbiden parameter change")
         log.I("test OK")
 
     @unittest.expectedFailure
@@ -211,7 +211,7 @@ class TestCases(PfwTestCase):
                                   % (self.param_name, err))
         assert round(float(out), 6) == float(value), "ERROR : BLACKBOARD - Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7') == hex_value, "ERROR : FILESYSTEM - parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q0.7') == hex_value, "ERROR : FILESYSTEM - parameter update error"
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -235,7 +235,7 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMax_Overflow.__doc__)
         value = "0.992189"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q0.7')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
@@ -244,5 +244,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q0.7') == param_check, log.F("FILESYSTEM - Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q0.7') == param_check, log.F("FILESYSTEM - Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py b/test/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py
index e1fc30f..83269ef 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py
@@ -101,7 +101,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 1) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q3.4') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -139,7 +139,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 4) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q3.4') == hex_value, "FILESYSTEM : parameter update error"
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -164,7 +164,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         value = "-8.0001"
         log.I("Setting %s to value %s" % (self.type_name, value))
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q3.4')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -172,7 +172,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q3.4') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -210,7 +210,7 @@ class TestCases(PfwTestCase):
         assert round(float(out), 4) == float(value), log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                            % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q3.4') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -234,7 +234,7 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMax_Overflow.__doc__)
         value = "7.9376"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q3.4')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
@@ -243,5 +243,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q3.4') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q3.4') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py b/test/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py
index ea83d5f..029af64 100755
--- a/test/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py
@@ -101,7 +101,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value),  log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                   % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -139,7 +139,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value),  log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                   % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -163,7 +163,7 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMin_Overflow.__doc__)
         value = "-128.1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q7.0')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
@@ -172,7 +172,7 @@ class TestCases(PfwTestCase):
         assert out != "Done",  log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                      % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0') == param_check,  log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q7.0') == param_check,  log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -210,7 +210,7 @@ class TestCases(PfwTestCase):
         assert float(out) == float(value),  log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                                   % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -234,7 +234,7 @@ class TestCases(PfwTestCase):
         """
         log.D(self.test_TypeMax_Overflow.__doc__)
         value = "127.1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0')
+        param_check = commands.getoutput('cat $PFW_RESULT/FP8_Q7.0')
         log.I("Setting %s to value %s" % (self.type_name, value))
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
@@ -243,5 +243,5 @@ class TestCases(PfwTestCase):
         assert out != "Done",  log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                      % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/FP8_Q7.0') == param_check,  log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/FP8_Q7.0') == param_check,  log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tINT16.py b/test/functional-tests/PfwTestCase/Types/tINT16.py
index f3ce617..f927cda 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT16.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT16.py
@@ -99,7 +99,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                   % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -137,7 +137,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                   % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -162,7 +162,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("INT16 parameter min value out of bounds = -1001")
         value = "-1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT16')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -170,7 +170,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -208,7 +208,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -233,7 +233,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("INT16 parameter max value out of bounds = 1001")
         value = "1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT16')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -241,5 +241,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py b/test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py
index 81fdf35..50a19bc 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py
@@ -64,7 +64,7 @@ class TestCases(PfwTestCase):
 
     def setUp(self):
         self.param_name = "/Test/Test/TEST_DIR/INT16_ARRAY"
-        self.param_short_name = "$PFW_FILESYSTEM/INT16_ARRAY"
+        self.param_short_name = "$PFW_RESULT/INT16_ARRAY"
         print '\r'
         self.pfw.sendCmd("setTuningMode", "on")
         print '\r'
diff --git a/test/functional-tests/PfwTestCase/Types/tINT16_Max.py b/test/functional-tests/PfwTestCase/Types/tINT16_Max.py
index e0854ed..968f3d2 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT16_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT16_Max.py
@@ -99,7 +99,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -137,7 +137,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -162,7 +162,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("INT16_Max parameter min value out of bounds = -32769")
         value = "-32769"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT16_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -170,7 +170,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -208,7 +208,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -233,7 +233,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("INT16_Max parameter max value out of bounds = 32768")
         value = "32768"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT16_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -241,5 +241,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tINT32.py b/test/functional-tests/PfwTestCase/Types/tINT32.py
index 45f837e..579e4f8 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT32.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT32.py
@@ -95,7 +95,7 @@ class TestCases(PfwTestCase):
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT32') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMin(self):
@@ -129,7 +129,7 @@ class TestCases(PfwTestCase):
         assert err == None, "PFW : Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT32') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMin_Overflow(self):
@@ -154,13 +154,13 @@ class TestCases(PfwTestCase):
         print self.test_TypeMin_Overflow.__doc__
         print "INFO : INT32 parameter min value out of bounds = -1001"
         value = "-1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT32')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT32')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out != "Done", "PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32') == param_check, "FILESYSTEM : Forbiden parameter change"
+        assert commands.getoutput('cat $PFW_RESULT/INT32') == param_check, "FILESYSTEM : Forbiden parameter change"
         print "INFO : test OK"
 
     def test_TypeMax(self):
@@ -194,7 +194,7 @@ class TestCases(PfwTestCase):
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT32') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMax_Overflow(self):
@@ -219,11 +219,11 @@ class TestCases(PfwTestCase):
         print self.test_TypeMax_Overflow.__doc__
         print "INFO : INT32 parameter max value out of bounds = 1001"
         value = "1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT32')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT32')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out != "Done", "PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32') == param_check, "FILESYSTEM : Forbiden parameter change"
+        assert commands.getoutput('cat $PFW_RESULT/INT32') == param_check, "FILESYSTEM : Forbiden parameter change"
         print "INFO : test OK"
diff --git a/test/functional-tests/PfwTestCase/Types/tINT32_Max.py b/test/functional-tests/PfwTestCase/Types/tINT32_Max.py
index 91444d9..147e7d4 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT32_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT32_Max.py
@@ -99,7 +99,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -136,7 +136,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -161,7 +161,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("INT32_Max parameter min value out of bounds = -2147483649")
         value = "-2147483649"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT32_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -169,7 +169,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -207,7 +207,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -232,7 +232,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("INT32_Max parameter max value out of bounds = 2147483648")
         value = "2147483648"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT32_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -240,5 +240,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tINT8.py b/test/functional-tests/PfwTestCase/Types/tINT8.py
index eeb594f..55612c5 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT8.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT8.py
@@ -99,7 +99,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -137,7 +137,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -162,7 +162,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("INT8 parameter min value out of bounds = -101")
         value = "-101"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT8')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -170,7 +170,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -208,7 +208,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -233,7 +233,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("INT8 parameter max value out of bounds = 101")
         value = "101"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT8')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -241,5 +241,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/INT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tINT8_Max.py b/test/functional-tests/PfwTestCase/Types/tINT8_Max.py
index b3792e0..2c42d96 100644
--- a/test/functional-tests/PfwTestCase/Types/tINT8_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tINT8_Max.py
@@ -95,7 +95,7 @@ class TestCases(PfwTestCase):
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMin(self):
@@ -129,7 +129,7 @@ class TestCases(PfwTestCase):
         assert err == None, "PFW : Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMin_Overflow(self):
@@ -154,13 +154,13 @@ class TestCases(PfwTestCase):
         print self.test_TypeMin_Overflow.__doc__
         print "INFO : INT8_Max parameter min value out of bounds = -129"
         value = "-129"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT8_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out != "Done", "PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max') == param_check, "FILESYSTEM : Forbiden parameter change"
+        assert commands.getoutput('cat $PFW_RESULT/INT8_Max') == param_check, "FILESYSTEM : Forbiden parameter change"
         print "INFO : test OK"
 
     def test_TypeMax(self):
@@ -194,7 +194,7 @@ class TestCases(PfwTestCase):
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out == value, "BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
+        assert commands.getoutput('cat $PFW_RESULT/INT8_Max') == hex_value, "FILESYSTEM : parameter update error"
         print "INFO : test OK"
 
     def test_TypeMax_Overflow(self):
@@ -219,11 +219,11 @@ class TestCases(PfwTestCase):
         print self.test_TypeMax_Overflow.__doc__
         print "INFO : INT8_Max parameter max value out of bounds = 128"
         value = "128"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/INT8_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
         assert out != "Done", "PFW : Error not detected when setting parameter %s out of bounds" % (self.param_name)
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/INT8_Max') == param_check, "FILESYSTEM : Forbiden parameter change"
+        assert commands.getoutput('cat $PFW_RESULT/INT8_Max') == param_check, "FILESYSTEM : Forbiden parameter change"
         print "INFO : test OK"
diff --git a/test/functional-tests/PfwTestCase/Types/tParameter_Block.py b/test/functional-tests/PfwTestCase/Types/tParameter_Block.py
index bc763bd..dcbe098 100644
--- a/test/functional-tests/PfwTestCase/Types/tParameter_Block.py
+++ b/test/functional-tests/PfwTestCase/Types/tParameter_Block.py
@@ -51,6 +51,7 @@ Test cases :
     - Testing error : Try to set an undefined param
 """
 import commands
+import unittest
 from Util.PfwUnitTestLib import PfwTestCase
 from Util import ACTLogging
 log=ACTLogging.Logger()
@@ -65,13 +66,13 @@ class TestCases(PfwTestCase):
 
         #UINT8_0, size = 8
         self.param_name.append(self.block_name+"/UINT8")
-        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT8")
+        self.filesystem_name.append("$PFW_RESULT/BLOCK_UINT8")
         #UINT16_1, size = 16
         self.param_name.append(self.block_name+"/UINT16")
-        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT16")
+        self.filesystem_name.append("$PFW_RESULT/BLOCK_UINT16")
         #UINT32_2, size = 32
         self.param_name.append(self.block_name+"/UINT32")
-        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT32")
+        self.filesystem_name.append("$PFW_RESULT/BLOCK_UINT32")
 
         self.pfw.sendCmd("setTuningMode", "on")
 
@@ -79,6 +80,7 @@ class TestCases(PfwTestCase):
         self.pfw.sendCmd("setTuningMode", "off")
 
 
+    @unittest.expectedFailure
     def test_Nominal_Case(self):
         """
         Testing BLOCK_PARAMETER in nominal case
diff --git a/test/functional-tests/PfwTestCase/Types/tRAW.py b/test/functional-tests/PfwTestCase/Types/tRAW.py
index 8153c32..dc3a037 100644
--- a/test/functional-tests/PfwTestCase/Types/tRAW.py
+++ b/test/functional-tests/PfwTestCase/Types/tRAW.py
@@ -75,9 +75,9 @@ log=ACTLogging.Logger()
 class TestCases(PfwTestCase):
     def setUp(self):
         self.param_name = "/Test/Test/TEST_DIR/UINT16_Max"
-        self.filesystem_name="$PFW_FILESYSTEM/UINT16_Max"
+        self.filesystem_name="$PFW_RESULT/UINT16_Max"
         self.param_name_2 = "/Test/Test/TEST_DIR/UINT16"
-        self.filesystem_name_2="$PFW_FILESYSTEM/UINT16"
+        self.filesystem_name_2="$PFW_RESULT/UINT16"
         self.pfw.sendCmd("setTuningMode", "on")
 
     def tearDown(self):
diff --git a/test/functional-tests/PfwTestCase/Types/tSTRING_128.py b/test/functional-tests/PfwTestCase/Types/tSTRING_128.py
index 0ed6e85..26c5bc0 100644
--- a/test/functional-tests/PfwTestCase/Types/tSTRING_128.py
+++ b/test/functional-tests/PfwTestCase/Types/tSTRING_128.py
@@ -91,7 +91,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("when getting parameter %s -> %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
 
     def test_Empty_String_Case(self):
         """
@@ -120,7 +120,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("when getting parameter %s -> %s" % (self.param_name, err))
         assert out == "", log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == "", log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == "", log.F("FILESYSTEM : parameter update error")
 
     def test_OverSize_String_Case(self):
         """
@@ -142,13 +142,13 @@ class TestCases(PfwTestCase):
         value=""
         for i in range(self.size_max+1):
             value=value+str(random.choice(string.letters))
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128')
+        param_check = commands.getoutput('cat $PFW_RESULT/STR_CHAR128')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s -> %s" % (self.param_name, err))
         assert out != "Done", log.F("Error not detected when setting parameter %s over size" % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
 
     def test_Full_Letters_String_Case(self):
         """
@@ -179,7 +179,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("When setting parameter %s : %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
 
     def test_Nominal_String_Case(self):
         """
@@ -208,7 +208,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("When setting parameter %s -> %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
 
     def test_Punctuation_Empty_Parenthese_String_Case(self):
         """
@@ -227,7 +227,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_Punctuation_Empty_Parenthese_String_Case.__doc__)
         value = "ParentheseTest()"
         log.I("STR_CHAR128 parameter Parenthese Char = %s" % (value))
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128')
+        param_check = commands.getoutput('cat $PFW_RESULT/STR_CHAR128')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, "'%s'" % (value))
         assert err == None, log.E("When setting parameter %s : %s" % (self.param_name, err))
@@ -237,7 +237,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("When getting parameter %s : %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
 
     def test_Punctuation_Full_Parenthese_String_Case(self):
         """
@@ -256,7 +256,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_Punctuation_Full_Parenthese_String_Case.__doc__)
         value = "ParentheseTest(test)"
         log.I("STR_CHAR128 parameter Parenthese Char = %s" % (value))
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128')
+        param_check = commands.getoutput('cat $PFW_RESULT/STR_CHAR128')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, "'%s'" % value)
         assert err == None, log.E("When setting parameter %s : %s" % (self.param_name, err))
@@ -266,7 +266,7 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("When getting parameter %s : %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value, log.F("FILESYSTEM : parameter update error")
 
     def test_SpaceChar_String_Case(self):
         """
@@ -295,4 +295,4 @@ class TestCases(PfwTestCase):
         assert err == None, log.E("When setting parameter %s : %s" % (self.param_name, err))
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value_check, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/STR_CHAR128') == value_check, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/STR_CHAR128') == value_check, log.F("FILESYSTEM : parameter update error")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT16.py b/test/functional-tests/PfwTestCase/Types/tUINT16.py
index 5be2189..5237a3d 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT16.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT16.py
@@ -103,7 +103,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -141,7 +141,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -166,7 +166,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT16 parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT16')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -174,7 +174,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -212,7 +212,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -237,7 +237,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT16 parameter max value out of bounds = 1001")
         value = "1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT16')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT16')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -245,5 +245,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT16_Max.py b/test/functional-tests/PfwTestCase/Types/tUINT16_Max.py
index 30f25a9..cf9939c 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT16_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT16_Max.py
@@ -102,7 +102,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -140,7 +140,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -165,7 +165,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT16_Max parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT16_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -173,7 +173,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -211,7 +211,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -236,7 +236,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT16_Max parameter max value out of bounds = 65536")
         value = "65536"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT16_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -244,5 +244,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT32.py b/test/functional-tests/PfwTestCase/Types/tUINT32.py
index 662fe9a..f31361a 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT32.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32.py
@@ -102,7 +102,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -140,7 +140,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -165,7 +165,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT32 parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT32')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT32')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -173,7 +173,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -211,7 +211,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -236,7 +236,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT32 parameter max value out of bounds = 1001")
         value = "1001"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT32')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT32')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -244,5 +244,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py b/test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py
index a5e0cb0..a20d404 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py
@@ -65,7 +65,7 @@ class TestCases(PfwTestCase):
 
     def setUp(self):
         self.param_name = "/Test/Test/TEST_DIR/UINT32_ARRAY"
-        self.param_short_name = "$PFW_FILESYSTEM/UINT32_ARRAY"
+        self.param_short_name = "$PFW_RESULT/UINT32_ARRAY"
         print '\r'
         self.pfw.sendCmd("setTuningMode", "on")
         print '\r'
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py b/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py
index b99dd1b..2e99495 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py
@@ -102,7 +102,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -140,7 +140,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -165,7 +165,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT32_Max parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT32_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -173,7 +173,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -211,7 +211,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -236,7 +236,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT32_Max parameter max value out of bounds = 4294967296")
         value = "4294967296"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT32_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -244,5 +244,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT8.py b/test/functional-tests/PfwTestCase/Types/tUINT8.py
index d65a44e..b41712b 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT8.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8.py
@@ -101,7 +101,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -139,7 +139,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -164,7 +164,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT8 parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT8')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -172,7 +172,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -210,7 +210,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -235,7 +235,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT8 parameter max value out of bounds = 101")
         value = "101"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT8')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT8')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -243,5 +243,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py b/test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py
index 9f82a36..89be43c 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py
@@ -65,7 +65,7 @@ class TestCases(PfwTestCase):
 
     def setUp(self):
         self.param_name = "/Test/Test/TEST_DIR/UINT8_ARRAY"
-        self.param_short_name = "$PFW_FILESYSTEM/UINT8_ARRAY"
+        self.param_short_name = "$PFW_RESULT/UINT8_ARRAY"
         print '\r'
         self.pfw.sendCmd("setTuningMode", "on")
         print '\r'
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py b/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py
index 1d6b47a..4e40867 100644
--- a/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py
@@ -102,7 +102,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin(self):
@@ -140,7 +140,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMin_Overflow(self):
@@ -165,7 +165,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMin_Overflow.__doc__)
         log.I("UINT8_Max parameter min value out of bounds = -1")
         value = "-1"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT8_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -173,7 +173,7 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")
 
     def test_TypeMax(self):
@@ -211,7 +211,7 @@ class TestCases(PfwTestCase):
         assert out == value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
                                    % (self.param_name, value, out))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
         log.I("test OK")
 
     def test_TypeMax_Overflow(self):
@@ -236,7 +236,7 @@ class TestCases(PfwTestCase):
         log.D(self.test_TypeMax_Overflow.__doc__)
         log.I("UINT8_Max parameter max value out of bounds = 256")
         value = "256"
-        param_check = commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max')
+        param_check = commands.getoutput('cat $PFW_RESULT/UINT8_Max')
         #Set parameter value
         out, err = self.pfw.sendCmd("setParameter", self.param_name, value)
         assert err == None, log.E("when setting parameter %s : %s"
@@ -244,5 +244,5 @@ class TestCases(PfwTestCase):
         assert out != "Done", log.F("PFW : Error not detected when setting parameter %s out of bounds"
                                     % (self.param_name))
         #Check parameter value on filesystem
-        assert commands.getoutput('cat $PFW_FILESYSTEM/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        assert commands.getoutput('cat $PFW_RESULT/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
         log.I("test OK")