Parameter-Framework functional tests initial commit

Import of parameter-framework tests.
Simplified test engine and use of python test discovery.

Signed-off-by: Herve Garanto <hervex.garanto@intel.com>
Signed-off-by: Sylvère Billout <sylverex.billout@intel.com>
Signed-off-by: Philippe Colonges <philippeX.colonges@intel.com>
Signed-off-by: Jules Clero <julesx.clero@intel.com>

32 files changed, 8430 insertions, 0 deletions

diff --git a/test/functional-tests/PfwTestCase/Types/__init__.py b/test/functional-tests/PfwTestCase/Types/__init__.py
new file mode 100644
index 0000000..9fbd9f6
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/__init__.py
@@ -0,0 +1,32 @@
+"""
+Types Package : All testcases about differents types used in PFW :
+    - bit block
+    - boolean
+    - enum
+    - FP16_Q0_15 : 16bits Fixed point - 0 integer bits, 15 fractionnal bits
+    - FP16_Q15_0 : 16bits Fixed point - 15 integer bits, 0 fractionnal bits
+    - FP16_Q7_8 : 16bits Fixed point - 7 integer bits, 8 fractionnal bits
+    - FP32_Q0_31 : 32bits Fixed point - 0 integer bits, 31 fractionnal bits
+    - FP32_Q15_16 : 32bits Fixed point - 15 integer bits, 16 fractionnal bits
+    - FP32_Q31_0 : 32bits Fixed point - 31 integer bits, 0 fractionnal bits
+    - FP32_Q8_20 : 32bits Fixed point - 8 integer bits, 20 fractionnal bits
+    - FP8_Q0_7 : 8bits Fixed point - 0 integer bits, 7 fractionnal bits
+    - FP8_Q3_4 : 8bits Fixed point - 3 integer bits, 4 fractionnal bits
+    - FP8_Q7_0 : 8bits Fixed point - 7 integer bits, 0 fractionnal bits
+    - INT8 : signed integer 8 bits bounded
+    - INT8_MAX : signed integer 8 bits full range
+    - INT16 : signed integer 16 bits bounded
+    - INT16_MAX : signed integer 16 bits full range
+    - INT32 : signed integer 32 bits bounded
+    - INT32_MAX : signed integer 23 bits full range
+    - UINT8 : unsigned integer 8 bits bounded
+    - UINT8_MAX : unsigned integer 8 bits full range
+    - UINT16 : unsigned integer 16 bits bounded
+    - UINT16_MAX : unsigned integer 16 bits full range
+    - UINT32 : unsigned integer 32 bits bounded
+    - UINT32_MAX : unsigned integer 23 bits full range
+    - string
+    - raw data
+    - integer array
+    - parameter block
+"""
diff --git a/test/functional-tests/PfwTestCase/Types/tBit_Block.py b/test/functional-tests/PfwTestCase/Types/tBit_Block.py
new file mode 100644
index 0000000..6ea87bf
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tBit_Block.py
@@ -0,0 +1,319 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Bit block parameter type testcases.
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    Block size = 8bits :
+        - BIT_0_3, size = 3, pos=0
+        - BIT_3_1, size = 1, pos=3
+        - BIT_4_1, size = 1, pos=4
+        - BIT_6_2, size = 2, pos=6
+        - BIT_7_1, size = 1, pos=7
+
+Test cases :
+------------
+    - Testing nominal TestCase : set bit to bit
+    - Testing error testcase : set block in one shot
+    - Testing out of bound TestCase
+    - Testing conflicting TestCase : two bits at the same position
+    - Testing out of size TestCase : Bit define on a wrong position
+"""
+
+import commands
+import unittest
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT16 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.block_name = "/Test/Test/TEST_TYPES/BLOCK_8BIT"
+        self.filesystem_name="$PFW_FILESYSTEM/BLOCK_8BIT"
+
+        self.bit_name=[]
+
+        #BIT_0_3, size = 3, pos = 0
+        self.bit_name.append("/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_0_3")
+        #BIT_3_1, size = 1, pos = 3
+        self.bit_name.append("/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_3_1")
+        #BIT_4_1, size = 1, pos = 4
+        self.bit_name.append("/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_4_1")
+        #BIT_6_2, size = 2, pos = 6
+        self.bit_name.append("/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_6_2")
+        #BIT_7_1, size = 1, pos = 7
+        self.bit_name.append("/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_7_1")
+
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+
+    def test_Nominal_Case(self):
+        """
+        Testing Bit block parameter in nominal case
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set Bit parameter in nominal case :
+                    - BLOCK_BIT = 0b01011101, 0x5D, 93
+                    - BIT_0_3 = 5
+                    - BIT_3_1 = 1
+                    - BIT_4_1 = 1
+                    - BIT_6_1 = 1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - BIT parameters set to nominal value
+                - FILESYSTEM BLOCK_8BIT set to 0x5D
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+
+        value_bit=["5","1","1","1"]
+        filesystem_value=["0x5","0xd","0x1d","0x5d"]
+
+        for index_bit in range(4):
+            log.I("set parameter %s to %s"%(self.bit_name[index_bit],value_bit[index_bit]))
+            out,err = self.pfw.sendCmd("setParameter",self.bit_name[index_bit],value_bit[index_bit])
+            assert err == None, log.E("setParameter %s %s : %s" % (self.bit_name[index_bit],value_bit[index_bit], err))
+            assert out == "Done", log.F("setParameter %s %s" %(self.bit_name[index_bit],value_bit[index_bit]))
+            log.I("Check bit %s value"%(self.bit_name[index_bit]))
+            out,err = self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert err == None, log.E("getParameter %s : %s" % (self.block_name, err))
+            assert out == value_bit[index_bit], log.F("getParameter %s - Expected : %s Found : %s" %(self.bit_name[index_bit],value_bit[index_bit], out))
+            log.I("Check filesystem value")
+            assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value[index_bit], log.F("FILESYSTEM : parameter update error for %s after setting bit %s "%(self.block_name, self.bit_name[index_bit]))
+
+
+    def test_Set_Block_Directly_Case(self):
+        """
+        Testing setting Bit block parameter in one shot
+        -----------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set Bit block directly without setting bit to bit :
+                    - BLOCK_BIT = 0b01011101, 0x5D, 93
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Unable to set directly a block bit
+                - FILESYSTEM BLOCK_8BIT must not change
+        """
+        log.D(self.test_Set_Block_Directly_Case.__doc__)
+
+        value = "93"
+
+        log.I("Load the initial value of bit parameter")
+        init_value_bit=[]
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert err == None, log.E("getParameter %s"%self.bit_name[index_bit])
+            init_value_bit.append(out)
+
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+
+        log.I("Try to set parameter %s to %s, failed expected"%(self.block_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.block_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.block_name, value, err))
+        assert out != "Done", log.F("Error not detected when setting directly the block %s" % (self.block_name))
+        log.I("Try to get parameter %s to %s, failed expected"%(self.block_name,value))
+        out,err = self.pfw.sendCmd("getParameter",self.block_name, value)
+        assert err == None, log.E("getParameter %s : %s" % (self.block_name, err))
+        assert out != value, log.F("Error not detected when getting directly the block %s" % (self.block_name))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.block_name))
+
+        log.I("Check Bit value")
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert out==init_value_bit[index_bit], log.F("BLACKBOARD: Forbidden change value for bit %s - Expected : %s Found : %s"%(self.bit_name[index_bit],init_value_bit[index_bit],out))
+
+    def test_Out_Of_Bound_Bit_Value_Case(self):
+        """
+        Testing setting bit in out of bound
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set bit BIT_3_1 to 2
+                - check bit BIT_3_1 value
+                - check bit BIT_0_3 value
+                - check bit BIT_4_1 value
+                - check block bit Filesystem value
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected when setting BIT_3_1 to out of bound value
+                - FILESYSTEM BLOCK_8BIT must not change
+        """
+        log.D(self.test_Out_Of_Bound_Bit_Value_Case.__doc__)
+
+        bit_value="3"
+
+        log.I("Load the initial value of bit parameter")
+        init_value_bit=[]
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert err == None, log.E("getParameter %s"%self.bit_name[index_bit])
+            init_value_bit.append(out)
+
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+
+        log.I("set parameter %s to %s, failed expected"%(self.bit_name[1],bit_value))
+        out,err = self.pfw.sendCmd("setParameter",self.bit_name[1],bit_value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.bit_name[1],bit_value, err))
+        assert out != "Done", log.F("Error not detected when setting the bit %s to out of bound value %s" % (self.bit_name[1],bit_value))
+        log.I("Check Bit value")
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert out==init_value_bit[index_bit], log.F("BLACKBOARD: Forbidden change value for bit %s - Expected : %s Found : %s"%(self.bit_name[index_bit],init_value_bit[index_bit],out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.block_name))
+
+    def test_Undefined_Bit_Case(self):
+        """
+        Testing setting an undefined bit
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set bit BIT_UNDEF to 1
+                - check block bit Filesystem value
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected when setting BIT_UNDEF
+                - FILESYSTEM BLOCK_8BIT must not change
+        """
+        log.D(self.test_Undefined_Bit_Case.__doc__)
+
+        bit_value="1"
+        bit_undefined_name="/Test/Test/TEST_TYPES/BLOCK_8BIT/BIT_UNDEF"
+
+        log.I("Load the initial value of bit parameter")
+        init_value_bit=[]
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert err == None, log.E("getParameter %s"%self.bit_name[index_bit])
+            init_value_bit.append(out)
+
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+
+        log.I("set parameter %s to %s, failed expected"%(bit_undefined_name,bit_value))
+        out,err = self.pfw.sendCmd("setParameter",bit_undefined_name,bit_value)
+        assert err == None, log.E("setParameter %s %s : %s" % (bit_undefined_name,bit_value, err))
+        assert out != "Done", log.F("Error not detected when setting the bit %s to out of bound value %s" % (bit_undefined_name,bit_value))
+        log.I("Check Bit value")
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert out==init_value_bit[index_bit], log.F("BLACKBOARD: Forbidden change value for bit %s - Expected : %s Found : %s"%(self.bit_name[index_bit],init_value_bit[index_bit],out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.block_name))
+
+    @unittest.expectedFailure
+    def test_Position_Conflicting_Case(self):
+        """
+        Testing conflicting position
+        ----------------------------
+            Parameter :
+            ~~~~~~~~~~~
+                BIT_6_2 : Position = 6, size = 2 conflicting with
+                BIT_7_1 : Position = 7; size = 1
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set bit BIT_6_2 to 0
+                - set bit BIT_7_1 to 1
+                - check bit BIT_6_2 value
+                - check block bit Filesystem value
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Unable to define 2 bits at the same position
+        """
+        log.D(self.test_Position_Conflicting_Case.__doc__)
+
+        bit_value_6_2="0"
+        bit_value_7_1="1"
+
+        log.I("set parameter %s to %s"%(self.bit_name[3],bit_value_6_2))
+        out,err = self.pfw.sendCmd("setParameter",self.bit_name[3],bit_value_6_2)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.bit_name[3],bit_value_6_2, err))
+        assert out == "Done", log.F("setParameter %s %s" %(self.bit_name[3],bit_value_6_2))
+
+        log.I("Load the value of bit parameter")
+        init_value_bit=[]
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            init_value_bit.append(out)
+
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+
+        log.I("set parameter %s to %s, failed expected"%(self.bit_name[4],bit_value_7_1))
+        out,err = self.pfw.sendCmd("setParameter",self.bit_name[4],bit_value_7_1)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.bit_name[4],bit_value_7_1, err))
+        assert out != "Done", log.F("Error not detected when setting the conflicting bit %s" % (self.bit_name[4]))
+        log.I("Check Bit value")
+        for index_bit in range(4):
+            out,err=self.pfw.sendCmd("getParameter",self.bit_name[index_bit])
+            assert out==init_value_bit[index_bit], log.F("BLACKBOARD: Forbidden change value for bit %s - Expected : %s Found : %s"%(self.bit_name[index_bit],init_value_bit[index_bit],out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.block_name))
diff --git a/test/functional-tests/PfwTestCase/Types/tBoolean.py b/test/functional-tests/PfwTestCase/Types/tBoolean.py
new file mode 100644
index 0000000..0658964
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tBoolean.py
@@ -0,0 +1,161 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Boolean parameter type testcases.
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+
+Test cases :
+------------
+    - Testing minimum
+    - Testing maximum
+    - Testing negative value
+    - Testing overflow
+"""
+
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Class containing SET/GET tests on a Boolean parameter
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/BOOL"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def testBooleanMaximum(self):
+        """
+        Testing maximum value for boolean parameter
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set a boolean parameter to the max value 1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Boolean set to 1
+        """
+        log.D(self.testBooleanMaximum.__doc__)
+        value = "1"
+        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("When setting parameter %s : %s" % (self.param_name, out))
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert out == value, log.F("incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
+
+    def testBooleanMinimum(self):
+        """
+        Testing minimum value for boolean parameter
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set a boolean parameter to the min value 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Boolean set to 0
+        """
+        log.D(self.testBooleanMinimum.__doc__)
+        value = "0"
+        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("When setting parameter %s : %s" % (self.param_name, out))
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("Error when setting parameter %s : %s" % (self.param_name, err))
+        assert out == value, log.F("Incorrect value for %s, expected: %s, found: %s" % (self.param_name, value, out))
+
+    def testBooleanNegative(self):
+        """
+        Testing negative value for boolean parameter
+        --------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set a boolean parameter to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected, boolean not updated
+        """
+        print self.testBooleanNegative.__doc__
+        value = "-1"
+        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("When setting parameter %s : %s" % (self.param_name, out))
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert out != value, log.F("incorrect value for %s, expected: %s, found: %s") % (self.param_name, value, out)
+
+
+    def testBooleanOverflow(self):
+        """
+        Testing overflowed value for boolean parameter
+        ----------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set a boolean parameter to 2
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected, boolean not updated
+        """
+        print self.testBooleanOverflow.__doc__
+        value = "2"
+        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("When setting parameter %s : %s" % (self.param_name, out))
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert out != value, log.F("incorrect value for %s, expected: %s, found: %s") % (self.param_name, value, out)
diff --git a/test/functional-tests/PfwTestCase/Types/tEnum.py b/test/functional-tests/PfwTestCase/Types/tEnum.py
new file mode 100644
index 0000000..6dd41f4
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tEnum.py
@@ -0,0 +1,265 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Enum parameter type testcases.
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    Enum size = 8bits; 5 components :
+        - max range [-127,128]
+
+Test cases :
+------------
+    - Enum parameter nominal value = ENUM_NOMINAL : 5
+    - Enum parameter min value = ENUM_MIN : -127
+    - Enum parameter max value = ENUM_MAX : 128
+    - Enum parameter out of bound value = ENUM_OOB : 255
+    - Enum parameter out of size value = ENUM_OOS : 256
+    - Enum parameter undefined value = UNDEF
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT16 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_TYPES/ENUM"
+        self.filesystem_name="$PFW_FILESYSTEM/ENUM"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+
+    def test_Nominal_Case(self):
+        """
+        Testing Enum parameter in nominal case
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter in nominal case = ENUM_NOMINAL
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - ENUM parameter set to ENUM_NOMINAL
+                - FILESYSTEM set to 0x5
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        value = "ENUM_NOMINAL"
+        filesystem_value="0x5"
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out == "Done", log.F("setParameter %s %s - expected : Done : %s" % (self.param_name, value,out))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
+
+    def test_TypeMin(self):
+        """
+        Testing minimal value for Enum parameter
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter in min case = ENUM_MIN
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - ENUM parameter set to ENUM_MIN
+                - FILESYSTEM set to 0x80
+        """
+        log.D(self.test_TypeMin.__doc__)
+        value = "ENUM_MIN"
+        filesystem_value="0x80"
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out == "Done", log.F("setParameter %s %s - expected : Done : %s" % (self.param_name, value,out))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
+
+    def test_TypeMax(self):
+        """
+        Testing maximal value for Enum parameter
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter in max case = ENUM_MAX
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - ENUM parameter set to ENUM_MAX
+                - FILESYSTEM set to 0x7F
+        """
+        log.D(self.test_TypeMax.__doc__)
+        value = "ENUM_MAX"
+        filesystem_value="0x7f"
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out == "Done", log.F("setParameter %s %s - expected : Done : %s" % (self.param_name, value,out))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
+
+    def test_TypeUndefined(self):
+        """
+        Testing ENUM parameter in undefined reference case
+        --------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter = UNDEF
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected, parameter must not change
+                - FILESYSTEM must not change
+        """
+        log.D(self.test_TypeUndefined.__doc__)
+        value = "UNDEF"
+        log.I("Check parameter %s initial value"%(self.param_name))
+        init_parameter_value, err=self.pfw.sendCmd("getParameter",self.param_name)
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out != "Done", log.F("Error not detected when setParameter %s %s" % (self.param_name, value))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == init_parameter_value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,init_parameter_value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
+
+    def test_TypeOutOfBound(self):
+        """
+        Testing ENUM parameter in out of range case
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter in max case = ENUM_OOB : 255
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected, parameter must not change
+                - FILESYSTEM must not change
+        """
+        log.D(self.test_TypeOutOfBound.__doc__)
+        value = "ENUM_OOB"
+        log.I("Check parameter %s initial value"%(self.param_name))
+        init_parameter_value, err=self.pfw.sendCmd("getParameter",self.param_name)
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out != "Done", log.F("Error not detected when setParameter %s %s" % (self.param_name, value))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == init_parameter_value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,init_parameter_value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
+
+    def test_TypeOutOfSize(self):
+        """
+        Testing ENUM parameter in out of size case
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - ENUM parameter in max case = ENUM_OOS : 256
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected, parameter must not change
+                - FILESYSTEM must not change
+        """
+        log.D(self.test_TypeOutOfBound.__doc__)
+        value = "ENUM_OOS"
+        log.I("Check parameter %s initial value"%(self.param_name))
+        init_parameter_value, err=self.pfw.sendCmd("getParameter",self.param_name)
+        init_filesystem_value=commands.getoutput("cat %s"%(self.filesystem_name))
+        log.I("Set parameter %s to %s"%(self.param_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name, value)
+        assert err == None, log.E("setParameter %s %s : %s" % (self.param_name, value, err))
+        assert out != "Done", log.F("Error not detected when setParameter %s %s" % (self.param_name, value))
+        log.I("Check Enum parameter state")
+        out, err = self.pfw.sendCmd("getParameter",self.param_name)
+        assert err == None, log.E("getParameter %s : %s" % (self.param_name, err))
+        assert out == init_parameter_value, log.F("getParameter %s - expected : %s , found : %s" % (self.param_name,init_parameter_value,out))
+        log.I("Check filesystem value")
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == init_filesystem_value, log.F("FILESYSTEM : parameter update error for %s"%(self.param_name))
diff --git a/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py b/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py
new file mode 100755
index 0000000..fe04e49
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py
@@ -0,0 +1,232 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP16_Q0.15
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP16_Q0.15 :
+        - size = 16 bits
+        - 0 integer bits, 15 fractionnal bits
+        - range : [-1, 0.999969]
+
+Test cases :
+------------
+    - FP16_Q0.15 parameter min value = -1
+    - FP16_Q0.15 parameter min value out of bounds = -1.00001
+    - FP16_Q0.15 parameter max value = 0.999969
+    - FP16_Q0.15 parameter max value out of bounds = 0.99997
+    - FP16_Q0.15 parameter in nominal case = 0.2453
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP16_Q0.15 - range [-1, 0.999969]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP16_Q0.15"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.type_name = "FP16_Q0.15"
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP16_Q0.15 in nominal case = 0.2453
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.15 parameter in nominal case = 0.2453
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.15 parameter set to 0.2453
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        value = "0.2453"
+        hex_value = "0x1f66"
+        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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP16_Q0.15 minimal value = -1
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.15 parameter min value = -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.15 parameter set to -1
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        value = "-1"
+        hex_value = "0x8000"
+        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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP16_Q0.15 parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.15 to -1.00001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q0.15 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin_Overflow.__doc__)
+        value = "-1.00001"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP16_Q0.15 parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.15 to 0.999969
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.15 parameter set to 0.999969
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        value = "0.999969"
+        hex_value = "0x7fff"
+        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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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, 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")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP16_Q0.15 parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.15 to 0.99997
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q0.15 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax_Overflow.__doc__)
+        value = "0.99997"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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")
+        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
new file mode 100755
index 0000000..b5d8b15
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py
@@ -0,0 +1,230 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP16_Q15.0
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP16_Q15.0 :
+        - size = 16 bits
+        - 15 integer bits, 0 fractionnal bits
+        - range : [-32768,32767]
+
+Test cases :
+------------
+    - FP16_Q15.0 parameter min value = -32768
+    - FP16_Q15.0 parameter min value out of bounds = -32768.1
+    - FP16_Q15.0 parameter max value = 32767
+    - FP16_Q15.0 parameter max value out of bounds = 32767.1
+    - FP16_Q15.0 parameter in nominal case = 2222
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP16_Q15.0 - range [-32768,32767]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP16_Q15.0"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+    def test_Nominal_Case(self):
+        """
+        Testing FP16_Q15.2 in nominal case = 2222
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q15.0 parameter in nominal case = 2222
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q15.0 parameter set to 2222
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP16_Q15.0 parameter in nominal case = 2222")
+        value = "2222"
+        hex_value = "0x8ae"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP16_Q15.0 minimal value = -32768
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q15.0 parameter min value = -32768
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q15.0 parameter set to -32768
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP16_Q15.0 parameter min value = -32768")
+        value = "-32768"
+        hex_value = "0x8000"
+        #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("Error when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP16_Q15.0 parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q15.0 to -32768.1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q15.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP16_Q15.0 parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q15.0 to 32767
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q15.0 parameter set to 32767
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP16_Q15.0 parameter max value = 32767")
+        value = "32767"
+        hex_value = "0x7fff"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP16_Q15.0 parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q15.0 to 32767.1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q15.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        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
new file mode 100755
index 0000000..f082175
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py
@@ -0,0 +1,235 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP16_Q7.8
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP16_Q7.8 :
+        - size = 16 bits
+        - 7 integer bits, 8 fractionnal bits
+        - range : [-128, 127.996]
+
+Test cases :
+------------
+    - FP16_Q7.8 parameter min value = -128
+    - FP16_Q7.8 parameter min value out of bounds = -128.001
+    - FP16_Q7.8 parameter max value = 127.996
+    - FP16_Q7.8 parameter max value out of bounds = 127.997
+    - FP16_Q7.8 parameter in nominal case = 23.59
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP16_Q7.8 - range [-128, 127.996]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP16_Q7.8"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.type_name = "FP16_Q7.8"
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP16_Q7.8 in nominal case = 23.59
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q7.8 parameter in nominal case = 23.59
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q7.8 parameter set to 23.59
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP16_Q7.8 parameter in nominal case = 23.59")
+        value = "23.590"
+        hex_value = "0x1797"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP16_Q7.8 minimal value = -128
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q7.8 parameter min value = -128
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q7.8 parameter set to -128
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP16_Q7.8 parameter min value = -128")
+        value = "-128"
+        hex_value = "0x8000"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP16_Q7.8 parameter value out of negative range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q7.8 to -128.001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q7.8 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP16_Q7.8 parameter maximum value
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q7.8 to 127.996
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q7.8 parameter set to 127.996
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP16_Q7.8 parameter max value = 127.996")
+        value = "127.996"
+        hex_value = "0x7fff"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP16_Q7.8 parameter value out of positive range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q7.8 to 127.997
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q7.8 parameter not updated
+
+        """
+        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')
+        #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")
+        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
new file mode 100755
index 0000000..f521ef7
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py
@@ -0,0 +1,236 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP16_Q0.31
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP16_Q0.31 :
+        - size = 32 bits
+        - 0 integer bits, 31 fractionnal bits
+        - range : [-1, 0.9999999995343387126922607421875]
+
+Test cases :
+------------
+    - FP16_Q0.31 parameter min value = -1
+    - FP16_Q0.31 parameter min value out of bounds = -1.0000000001
+    - FP16_Q0.31 parameter max value = 0.9999999995
+    - FP16_Q0.31 parameter max value out of bounds = 1
+    - FP16_Q0.31 parameter in nominal case = 0.5000000000
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP32_Q0.31 - range [-1,0.9999999995343387126922607421875]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP32_Q0.31"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP16_Q0.31 in nominal case = 0.500000000
+        ------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.31 parameter in nominal case = 0.500000000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.31 parameter set to 0.500000000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP32_Q0.31 parameter in nominal case = 0.500000000")
+        value = "0.5000000000"
+        hex_value = "0x40000000"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP16_Q0.31 minimal value = -1
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.31 parameter min value = -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.31 parameter set to -1
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP32_Q0.31 parameter min value = -1")
+        value = "-1"
+        hex_value = "0x80000000"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP16_Q0.31 parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.31 to -1.000000001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q0.31 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP16_Q0.31 parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.31 to 0.9999999995
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP16_Q0.31 parameter set to 0.9999999995
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP32_Q0.31 parameter max value = 0.9999999995")
+        value = "0.9999999995"
+        hex_value = "0x7fffffff"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP16_Q0.31 parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP16_Q0.31 to 1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP16_Q0.31 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        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
new file mode 100755
index 0000000..620f32e
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py
@@ -0,0 +1,238 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP32_Q15.16
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP32_Q15.16 :
+        - size = 32 bits
+        - 15 integer bits, 16 fractionnal bits
+        - range : [-32768, 32767.9999847412109375]
+
+Test cases :
+------------
+    - FP32_Q15.16 parameter min value = -32768
+    - FP32_Q15.16 parameter min value out of bounds = -32768.00001
+    - FP32_Q15.16 parameter max value = 32767.99998
+    - FP32_Q15.16 parameter max value out of bounds = 32767.999985
+    - FP32_Q15.16 parameter in nominal case = 12345.12345
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP32_Q15.16 - range [-32768,32767.9999847412109375]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP32_Q15.16"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP32_Q15.16 in nominal case = 12345.12345
+        -------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q15.16 parameter in nominal case = 12345.12345
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q15.16 parameter set to 12345.12345
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP32_Q15.16 parameter in nominal case = 12345.12345")
+        value = "12345.1234"
+        hex_value = "0x30391f97"
+        #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("when setting parameter %s : %s" % (self.param_name, err))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q15.16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+
+    def test_TypeMin(self):
+        """
+        Testing FP32_Q15.16 minimal value = -32768
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q15.16 parameter min value = -32768
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q15.16 parameter set to -32768
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP32_Q15.16 parameter min value = -32768")
+        value = "-32768"
+        hex_value = "0x80000000"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None,log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP32_Q15.16 parameter value out of negative range
+        ---------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q15.16 to -32768.00001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q15.16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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_Q15.16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP32_Q15.16 parameter maximum value
+        -------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q15.16 to 32767.99998
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q15.16 parameter set to 32767.99998
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP32_Q15.16 parameter max value = 32767.99998")
+        value = "32767.99998"
+        hex_value = "0x7fffffff"
+        #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("when setting parameter %s : %s" % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s" % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP32_Q15.16 parameter value out of positive range
+        ---------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q15.16 to 32767.999985
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q15.16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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_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
new file mode 100755
index 0000000..25c3741
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py
@@ -0,0 +1,246 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP32_Q31.0
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP32_Q31.0 :
+        - size = 32 bits
+        - 31 integer bits, 0 fractionnal bits
+        - range : [-2147483648, 2147483647]
+
+Test cases :
+------------
+    - FP32_Q31.0 parameter min value = -2147483648
+    - FP32_Q31.0 parameter min value out of bounds = -4147483649
+    - FP32_Q31.0 parameter max value = 2147483647
+    - FP32_Q31.0 parameter max value out of bounds = 12147483648
+    - FP32_Q31.0 parameter in nominal case = 2222
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP32_Q31.0 - range [-2147483648,2147483647]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP32_Q31.0"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP32_Q31.0 in nominal case = 2222
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q31.0 parameter in nominal case = 2222
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q31.0 parameter set to 2222
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP32_Q31.0 parameter in nominal case = 2222")
+        value = "2222"
+        hex_value = "0x8ae"
+        #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("when setting parameter %s : %s"
+                                    % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP32_Q31.0 minimal value = -2147483648
+        ----------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q31.0 parameter min value = -2147483648
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q31.0 parameter set to -2147483648
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP32_Q31.0 parameter min value = -2147483648")
+        value = "-2147483648"
+        hex_value = "0x80000000"
+        #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("when setting parameter %s : %s"
+                                    % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP32_Q31.0 parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q31.0 to -4147483649
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q31.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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_Q31.0') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP32_Q31.0 parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q31.0 to 2147483647
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q31.0 parameter set to 2147483647
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP32_Q31.0 parameter max value = 2147483647")
+        value = "2147483647"
+        hex_value = "0x7fffffff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q31.0') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP32_Q31.0 parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q31.0 to 12147483648
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q31.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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_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
new file mode 100755
index 0000000..ed6b1c6
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py
@@ -0,0 +1,244 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP32_Q8.20
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP32_Q8.20 :
+        - size = 32 bits
+        - 8 integer bits, 20 fractionnal bits
+        - range : [-256, 255.999999]
+
+Test cases :
+------------
+    - FP32_Q8.20 parameter min value = -256
+    - FP32_Q8.20 parameter min value out of bounds = -500
+    - FP32_Q8.20 parameter max value = 255.999999
+    - FP32_Q8.20 parameter max value out of bounds = 3200.8888
+    - FP32_Q8.20 parameter in nominal case = -128.123456
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP32_Q8.20 - range [-256,255,999999046]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP32_Q8.20"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP32_Q8.20 in nominal case = -128.123456
+        ------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q8.20 parameter in nominal case = -128.123456
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q8.20 parameter set to -128.123456
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("FP32_Q8.20 parameter in nominal case = -128.123456")
+        value = "-128.123456"
+        hex_value = "0xbff03298"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP32_Q8.20 minimal value = -256
+        ---------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q8.20 parameter min value = -256
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q8.20 parameter set to -256
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("FP32_Q8.20 parameter min value = -256")
+        value = "-256"
+        hex_value = "0x80000000"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP32_Q8.20 parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q8.20 to -500
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q8.20 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP32_Q8.20 parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q8.20 to 255.999999
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP32_Q8.20 parameter set to 255.999999
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("FP32_Q8.20 parameter max value = 255.999999")
+        value = "255.999999"
+        hex_value = "0x7ffffff8"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP32_Q8.20') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP32_Q8.20 parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP32_Q8.20 to 3200.8888
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP32_Q8.20 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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")
+        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
new file mode 100755
index 0000000..8ffeb00
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py
@@ -0,0 +1,248 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP8_Q0.7
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP8_Q0.7 :
+        - size = 8 bits
+        - 0 integer bits, 7 fractionnal bits
+        - range : [-1, 0.992188]
+
+Test cases :
+------------
+    - FP8_Q0.7 parameter min value = -1
+    - FP8_Q0.7 parameter min value out of bounds = -1.000001
+    - FP8_Q0.7 parameter max value = 0.992188
+    - FP8_Q0.7 parameter max value out of bounds = 0.992189
+    - FP8_Q0.7 parameter in nominal case = 0.50
+"""
+import commands
+import unittest
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP8_Q0.7 - range [-1, 0.992188]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP8_Q0.7"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.type_name = "FP8_Q0.7"
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP8_Q0.7 in nominal case = 0.50
+        ---------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q0.7 parameter in nominal case = 0.50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q0.7 parameter set to 0.50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        value = "0.50"
+        hex_value = "0x40"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s"
+                                  % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP8_Q0.7 minimal value = -1
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q0.7 parameter min value = -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q0.7 parameter set to -1
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        value = "-1"
+        hex_value = "0x80"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q0.7') == hex_value, log.F("FILESYSTEM - parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP8_Q0.7 parameter value out of negative range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q0.7 to -1.00001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q0.7 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin_Overflow.__doc__)
+        value = "-1.000001"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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)
+        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/FP8_Q0.7') == param_check, log.F("FILESYSTEM - Forbiden parameter change")
+        log.I("test OK")
+
+    @unittest.expectedFailure
+    def test_TypeMax(self):
+        """
+        Testing FP8_Q0.7 parameter maximum value
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q0.7 to 0.992188
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q0.7 parameter set to 0.992188
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        value = "0.992188"
+        hex_value = "0x7f"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s"
+                                  % (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"
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP8_Q0.7 parameter value out of positive range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q0.7 to 0.992189
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q0.7 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax_Overflow.__doc__)
+        value = "0.992189"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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)
+        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/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
new file mode 100755
index 0000000..e1fc30f
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py
@@ -0,0 +1,247 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP8_Q0.7
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP8_Q0.7 :
+        - size = 8 bits
+        - 3 integer bits, 4 fractionnal bits
+        - range : [-8, 7.9375]
+
+Test cases :
+------------
+    - FP8_Q0.7 parameter min value = -8
+    - FP8_Q0.7 parameter min value out of bounds = -8.0001
+    - FP8_Q0.7 parameter max value = 7.9375
+    - FP8_Q0.7 parameter max value out of bounds = 7.9376
+    - FP8_Q0.7 parameter in nominal case = 4.3
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP8_Q3.4 - range [-8, 7.9375]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP8_Q3.4"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.type_name = "FP8_Q3.4"
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP8_Q3.4 in nominal case = 4.3
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q3.4 parameter in nominal case = 4.3
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q3.4 parameter set to 4.3
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        value = "4.3"
+        hex_value = "0x45"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("when setting parameter %s : %s"
+                                  % (self.param_name, err))
+        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")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP8_Q3.4 minimal value = -8
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q3.4 parameter min value = -8
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q3.4 parameter set to -8
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        value = "-8"
+        hex_value = "0x80"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q3.4') == hex_value, "FILESYSTEM : parameter update error"
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP8_Q3.4 parameter value out of negative range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q3.4 to -8.0001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q3.4 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/FP8_Q3.4') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP8_Q3.4 parameter maximum value
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q3.4 to 7.9375
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q3.4 parameter set to 7.9375
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        value = "7.9375"
+        hex_value = "0x7f"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q3.4') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP8_Q3.4 parameter value out of positive range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q3.4 to 7.9376
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q3.4 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax_Overflow.__doc__)
+        value = "7.9376"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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)
+        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/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
new file mode 100755
index 0000000..ea83d5f
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py
@@ -0,0 +1,247 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Fixed-Point parameter type testcases - FP8_Q7.0
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    FP8_Q7.0 :
+        - size = 8 bits
+        - 7 integer bits, 0 fractionnal bits
+        - range : [-128, 127]
+
+Test cases :
+------------
+    - FP8_Q7.0 parameter min value = -128
+    - FP8_Q7.0 parameter min value out of bounds = -128.1
+    - FP8_Q7.0 parameter max value = 127
+    - FP8_Q7.0 parameter max value out of bounds = 127.1
+    - FP8_Q7.0 parameter in nominal case = 64
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type FP8_Q7.0 - range [-128,127]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/FP8_Q7.0"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.type_name = "FP8_Q7.0"
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing FP8_Q7.0 in nominal case = 64
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q7.0 parameter in nominal case = 64
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q7.0 parameter set to 64
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        value = "64"
+        hex_value = "0x40"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing FP8_Q7.0 minimal value = -128
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q7.0 parameter min value = -128
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q7.0 parameter set to -128
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        value = "-128"
+        hex_value = "0x80"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing FP8_Q7.0 parameter value out of negative range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q7.0 to -128.1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q7.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin_Overflow.__doc__)
+        value = "-128.1"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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)
+        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/FP8_Q7.0') == param_check,  log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing FP8_Q7.0 parameter maximum value
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q7.0 to 127
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - FP8_Q7.0 parameter set to 127
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        value = "127"
+        hex_value = "0x7f"
+        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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/FP8_Q7.0') == hex_value,  log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing FP8_Q7.0 parameter value out of positive range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set FP8_Q7.0 to 127.1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - FP8_Q7.0 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax_Overflow.__doc__)
+        value = "127.1"
+        param_check = commands.getoutput('cat $PFW_FILESYSTEM/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)
+        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/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
new file mode 100644
index 0000000..f3ce617
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT16.py
@@ -0,0 +1,245 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT16
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT16 :
+        - size = 16
+        - range : [-1000, 1000]
+
+Test cases :
+------------
+    - INT16 parameter min value = -1000
+    - INT16 parameter min value out of bounds = -1001
+    - INT16 parameter max value = 1000
+    - INT16 parameter max value out of bounds = 1001
+    - INT16 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT16 - range [-1000, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT16"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT16 in nominal case = 50
+        ----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("INT16 parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing INT16 minimal value = -1000
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16 parameter min value = -1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16 parameter set to -1000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("INT16 parameter min value = -1000")
+        value = "-1000"
+        hex_value = "0xfc18"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT16 parameter value out of negative range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16 to -1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/INT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing INT16 parameter maximum value
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16 to 1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16 parameter set to 1000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("INT16 parameter max value = 1000")
+        value = "1000"
+        hex_value = "0x3e8"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT16 parameter value out of positive range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16 to 1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..81fdf35
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py
@@ -0,0 +1,323 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Array parameter type testcases : INT16 Array
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT16 Array = 16bits signed int array :
+        - Array size : 5
+        - values range : [-50, 50]
+
+Test cases :
+------------
+    - Testing nominal case
+    - Testing minimum
+    - Testing minimum overflow
+    - Testing maximum
+    - Testing maximum overflow
+    - Testing array index out of bounds
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+from ctypes import c_uint16
+
+
+class TestCases(PfwTestCase):
+
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT16_ARRAY"
+        self.param_short_name = "$PFW_FILESYSTEM/INT16_ARRAY"
+        print '\r'
+        self.pfw.sendCmd("setTuningMode", "on")
+        print '\r'
+        self.array_size = 5
+        self.array_min = -50
+        self.array_max = 50
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT16_ARRAY Nominal Case
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every INT16_ARRAY elements to autorized values
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+
+        for index in range (self.array_size):
+            indexed_array_value = index + self.array_min
+            if indexed_array_value>self.array_max:
+                indexed_array_value=self.array_max
+            hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+            #Check parameter value setting
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                      % (self.param_name, str(index), err))
+            assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                        % (self.param_name, str(index), out))
+            #Check parameter value on blackboard
+            out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+            assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                      % (self.param_name, str(index), err))
+            assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                          % (self.param_name, str(index), str(indexed_array_value), out))
+            #Check parameter value on filesystem
+            files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+            indexed_files_system_array_value = commands.getoutput(files_system_check)
+            assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                      % (self.param_name, str(index)))
+
+    def test_Min_Value(self):
+        """
+        Testing INT16_ARRAY minimum value
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every INT16_ARRAY elements to minimum values : 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Min_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Min_Value_Overflow(self):
+        """
+        Testing INT16_ARRAY parameter values out of negative range
+        ----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every INT16_ARRAY elements to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Min_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value - 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Max_Value(self):
+        """
+        Testing INT16_ARRAY maximum value
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every INT16_ARRAY elements to maximum values : 15
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Max_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Max_Value_Overflow(self):
+        """
+        Testing INT16_ARRAY parameter values out of positive range
+        ----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every INT16_ARRAY elements to 16
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Max_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value + 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Array_Index_Overflow(self):
+        """
+        Testing Array index out of bounds
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set an out of bounds array indexed element
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Array_Index_Overflow.__doc__)
+        index_values = (self.array_size-1, self.array_size+1, -1)
+        for index in index_values:
+            print index
+            indexed_array_value = self.array_max
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            #Check parameter value setting
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            if index in [0, self.array_size-1]:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), out))
+            else:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out != "Done", log.F("Error not detected when setting array %s index out of bounds"
+                                            % (self.param_name))
diff --git a/test/functional-tests/PfwTestCase/Types/tINT16_Max.py b/test/functional-tests/PfwTestCase/Types/tINT16_Max.py
new file mode 100644
index 0000000..e0854ed
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT16_Max.py
@@ -0,0 +1,245 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT16_Max
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT16_Max :
+        - size = 16
+        - range : [-32768, 32767]
+
+Test cases :
+------------
+    - INT16_Max parameter min value = -32768
+    - INT16_Max parameter min value out of bounds = -32769
+    - INT16_Max parameter max value = 32767
+    - INT16_Max parameter max value out of bounds = 32768
+    - INT16_Max parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT16_Max - range [-32768, 32767]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT16_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT16_Max in nominal case = 50
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16_Max parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_Max parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("INT16_Max parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing INT16_Max minimal value = -32768
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16_Max parameter min value = -32768
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_Max parameter set to -32768
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("INT16_Max parameter min value = -32768")
+        value = "-32768"
+        hex_value = "0x8000"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT16_Max parameter value out of negative range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16_Max to -32769
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT16_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/INT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing INT16_Max parameter maximum value
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16_Max to 32767
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT16_Max parameter set to 32767
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("INT16_Max parameter max value = 32767")
+        value = "32767"
+        hex_value = "0x7fff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT16_Max parameter value out of positive range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT16_Max to 32768
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT16_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..45f837e
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT32.py
@@ -0,0 +1,229 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT32
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT32 :
+        - size = 32
+        - range : [-1000, 1000]
+
+Test cases :
+------------
+    - INT32 parameter min value = -1000
+    - INT32 parameter min value out of bounds = -1001
+    - INT32 parameter max value = 1000
+    - INT32 parameter max value out of bounds = 1001
+    - INT32 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT32 - range [-1000, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT32"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT32 in nominal case = 50
+        ----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        print self.test_Nominal_Case.__doc__
+        print "INFO : INT32 parameter in nominal case = 50"
+        value = "50"
+        hex_value = "0x32"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMin(self):
+        """
+        Testing INT32 minimal value = -1000
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32 parameter min value = -1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32 parameter set to -1000
+                - Blackboard and filesystem values checked
+        """
+        print self.test_TypeMin.__doc__
+        print "INFO : INT32 parameter min value = -1000"
+        value = "-1000"
+        hex_value = "0xfffffc18"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT32 parameter value out of negative range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32 to -1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT32 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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"
+        print "INFO : test OK"
+
+    def test_TypeMax(self):
+        """
+        Testing INT32 parameter maximum value
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32 to 1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32 parameter set to 1000
+                - Blackboard and filesystem values checked
+        """
+        print self.test_TypeMax.__doc__
+        print "INFO : INT32 parameter max value = 1000"
+        value = "1000"
+        hex_value = "0x3e8"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT32 parameter value out of positive range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32 to 1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT32 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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"
+        print "INFO : test OK"
diff --git a/test/functional-tests/PfwTestCase/Types/tINT32_Max.py b/test/functional-tests/PfwTestCase/Types/tINT32_Max.py
new file mode 100644
index 0000000..91444d9
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT32_Max.py
@@ -0,0 +1,244 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT32_Max
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT32_Max :
+        - size = 16
+        - range : [-2147483648, 2147483647]
+
+Test cases :
+------------
+    - INT32_Max parameter min value = -2147483648
+    - INT32_Max parameter min value out of bounds = -2147483649
+    - INT32_Max parameter max value = 2147483647
+    - INT32_Max parameter max value out of bounds = 2147483648
+    - INT32_Max parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT32_Max - range [-2147483648, 2147483647]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT32_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT32_Max in nominal case = 50
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32_Max parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32_Max parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("INT32_Max parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing INT32_Max minimal value = -2147483648
+        ---------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32_Max parameter min value = -2147483648
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32_Max parameter set to -2147483648
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("INT32_Max parameter min value = -2147483648")
+        value = "-2147483648"
+        hex_value = "0x80000000"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT32_Max parameter value out of negative range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32_Max to -2147483649
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT32_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/INT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing INT32_Max parameter maximum value
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32_Max to 2147483647
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT32_Max parameter set to 1000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("INT32_Max parameter max value = 2147483647")
+        value = "2147483647"
+        hex_value = "0x7fffffff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT32_Max parameter value out of positive range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT32_Max to 2147483648
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT32_Max parameter not updated
+
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..eeb594f
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT8.py
@@ -0,0 +1,245 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT8
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT8 :
+        - size = 8
+        - range : [-100, 100]
+
+Test cases :
+------------
+    - INT8 parameter min value = -100
+    - INT8 parameter min value out of bounds = -101
+    - INT8 parameter max value = 100
+    - INT8 parameter max value out of bounds = 101
+    - INT8 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT8 - range [-100, 100]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT8"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT8 in nominal case = 50
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("INT8 parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing INT8 minimal value = -100
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8 parameter min value = -100
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8 parameter set to -100
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("INT8 parameter min value = -100")
+        value = "-100"
+        hex_value = "0x9c"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT8 parameter value out of negative range
+        --------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8 to -101
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT8 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/INT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing INT8 parameter maximum value
+        ------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8 to 100
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8 parameter set to 100
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("INT8 parameter max value = 100")
+        value = "100"
+        hex_value = "0x64"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/INT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT8 parameter value out of positive range
+        --------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8 to 101
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT8 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..b3792e0
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tINT8_Max.py
@@ -0,0 +1,229 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - INT8_Max
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    INT8_Max :
+        - size = 8
+        - range : [-128, 127]
+
+Test cases :
+------------
+    - INT8_Max parameter min value = -128
+    - INT8_Max parameter min value out of bounds = -129
+    - INT8_Max parameter max value = 127
+    - INT8_Max parameter max value out of bounds = 128
+    - INT8_Max parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type INT8_Max - range [-128, 127]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/INT8_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing INT8_Max in nominal case = 50
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8_Max parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8_Max parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        print self.test_Nominal_Case.__doc__
+        print "INFO : INT8_Max parameter in nominal case = 50"
+        value = "50"
+        hex_value = "0x32"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMin(self):
+        """
+        Testing INT8_Max minimal value = -128
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8_Max parameter min value = -128
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8_Max parameter set to -128
+                - Blackboard and filesystem values checked
+        """
+        print self.test_TypeMin.__doc__
+        print "INFO : INT8_Max parameter min value = -128"
+        value = "-128"
+        hex_value = "0x80"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing INT8_Max parameter value out of negative range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8_Max to -129
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT8_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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"
+        print "INFO : test OK"
+
+    def test_TypeMax(self):
+        """
+        Testing INT8_Max parameter maximum value
+        ----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8_Max to 127
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - INT8_Max parameter set to 127
+                - Blackboard and filesystem values checked
+        """
+        print self.test_TypeMax.__doc__
+        print "INFO : INT8_Max parameter max value = 127"
+        value = "127"
+        hex_value = "0x7f"
+        #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", out
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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"
+        print "INFO : test OK"
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing INT8_Max parameter value out of positive range
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set INT8_Max to 128
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - INT8_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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"
+        print "INFO : test OK"
diff --git a/test/functional-tests/PfwTestCase/Types/tParameter_Block.py b/test/functional-tests/PfwTestCase/Types/tParameter_Block.py
new file mode 100644
index 0000000..bc763bd
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tParameter_Block.py
@@ -0,0 +1,290 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Parameter block type testcases.
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    Block component - 3 UINT:
+        - UINT8, size = 8 bits, range : [0, 100]
+        - UINT16, size = 16 bits, range : [0, 1000]
+        - UINT16, size = 32 bits, range : [0, 1000]
+
+Test cases :
+------------
+    - Testing nominal situation
+    - Testing one-shot setting (setting directly a value for the block)
+    - Testing error : Out of range TestCase
+    - Testing error : Try to set an undefined param
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT16 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.block_name = "/Test/Test/TEST_TYPES/BLOCK_PARAMETER"
+
+        self.param_name = []
+        self.filesystem_name = []
+
+        #UINT8_0, size = 8
+        self.param_name.append(self.block_name+"/UINT8")
+        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT8")
+        #UINT16_1, size = 16
+        self.param_name.append(self.block_name+"/UINT16")
+        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT16")
+        #UINT32_2, size = 32
+        self.param_name.append(self.block_name+"/UINT32")
+        self.filesystem_name.append("$PFW_FILESYSTEM/BLOCK_UINT32")
+
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+
+    def test_Nominal_Case(self):
+        """
+        Testing BLOCK_PARAMETER in nominal case
+        ---------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT parameters in nominal case :
+                    - UINT8 = 5
+                    - UINT16 = 5
+                    - UINT32 = 5
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Parameters set to nominal value
+                - FILESYSTEM parameters set to nominal value
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+
+        value_param = ["5", "5", "5"]
+        filesystem_value = ["0x5", "0x5", "0x5"]
+
+        for index_param in range(len(self.param_name)) :
+            log.I("set parameter %s to %s"
+                  %(self.param_name[index_param],value_param[index_param]))
+            out,err = self.pfw.sendCmd("setParameter",self.param_name[index_param],value_param[index_param])
+            assert err == None, log.E("setParameter %s %s : %s"
+                                      % (self.param_name[index_param],value_param[index_param], err))
+            assert out == "Done", log.F("setParameter %s %s"
+                                        %(self.param_name[index_param],value_param[index_param]))
+            log.I("Check parameter %s value"
+                  %(self.param_name[index_param]))
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            assert err == None, log.E("getParameter %s : %s"
+                                      % (self.block_name, err))
+            assert out == value_param[index_param], log.F("getParameter %s - Expected : %s Found : %s"
+                                                          %(self.param_name[index_param],value_param[index_param], out))
+            log.I("Check filesystem value")
+            assert (commands.getoutput("cat %s" % (self.filesystem_name[index_param]))
+                    == filesystem_value[index_param]), log.F("FILESYSTEM : parameter update error for %s after setting %s "
+                                                             %(self.block_name, self.param_name[index_param]))
+
+
+    def test_Set_Block_Directly_Case(self):
+        """
+        Testing error BLOCK_PARAMETER : set block value directly
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set Param block directly without setting parameters :
+                    - BLOCK_PARAMETER = Dec : 1000000 Hexa : 0xF4240
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Unable to set directly a parameter block
+                - FILESYSTEM parameters set to nominal value
+        """
+        log.D(self.test_Set_Block_Directly_Case.__doc__)
+
+        value = "1000000"
+
+        log.I("Load the initial value of parameters")
+        init_value_param = []
+        init_filesystem_value = []
+
+        for index_param in range(len(self.param_name)):
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            init_value_param.append(out)
+            init_filesystem_value.append(commands.getoutput("cat %s"
+                                                            %(self.filesystem_name[index_param])))
+
+        log.I("Try to set parameter %s to %s, failed expected"
+              %(self.block_name,value))
+        out,err = self.pfw.sendCmd("setParameter",self.block_name, value)
+        assert err == None, log.E("setParameter %s %s : %s"
+                                   % (self.block_name, value, err))
+        assert out != "Done", log.F("Error not detected when setting directly the block %s"
+                                    % (self.block_name))
+        log.I("Try to get parameter %s to %s, failed expected"
+              %(self.block_name,value))
+        out,err = self.pfw.sendCmd("getParameter",self.block_name, value)
+        assert err == None, log.E("getParameter %s : %s"
+                                  % (self.block_name, err))
+        assert out != value, log.F("Error not detected when getting directly the block %s"
+                                   % (self.block_name))
+        log.I("Check filesystem value")
+        for index_param in range(len(self.param_name)):
+            assert (commands.getoutput("cat %s"%(self.filesystem_name[index_param]))
+                == init_filesystem_value[index_param]), log.F("FILESYSTEM : parameter update error for %s"
+                                                            %(self.block_name))
+
+        log.I("Check Param value")
+        for index_param in range(len(self.param_name)):
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            assert (out == init_value_param[index_param]), log.F("BLACKBOARD: Forbidden change value for parameter %s - Expected : %s Found : %s"
+                                                               %(self.param_name[index_param],init_value_param[index_param],out))
+
+    def test_Out_Of_Bound_Param_Value_Case(self):
+        """
+        Testing error BLOCK_PARAMETER : Out of range TestCase
+        -----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set param UINT16 to 65536
+                - check parameter UINT16 value
+                - check parameter UINT8 value
+                - check parameter UINT32 value
+                - check block Filesystem value
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected when setting UINT16_1 to wrong value
+                - FILESYSTEM parameters set to nominal value
+        """
+        log.D(self.test_Out_Of_Bound_Param_Value_Case.__doc__)
+
+        param_value = "65536"
+
+        log.I("Load the initial value of parameters")
+        init_value_param = []
+        init_filesystem_value = []
+
+        for index_param in range(len(self.param_name)):
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            init_value_param.append(out)
+            init_filesystem_value.append(commands.getoutput("cat %s"
+                                                            %(self.filesystem_name[index_param])))
+
+        log.I("set parameter %s to %s, failed expected"
+              %(self.param_name[1],param_value))
+        out,err = self.pfw.sendCmd("setParameter",self.param_name[1],param_value)
+        assert err == None, log.E("setParameter %s %s : %s"
+                                  % (self.param_name[1],param_value, err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s to out of bound value %s"
+                                    % (self.param_name[1],param_value))
+        log.I("Check parameter value")
+        for index_param in range(len(self.param_name)):
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            assert out == init_value_param[index_param], log.F("BLACKBOARD: Forbidden change value for %s - Expected : %s Found : %s"
+                                                             %(self.param_name[index_param],init_value_param[index_param],out))
+        log.I("Check filesystem value")
+        assert (commands.getoutput("cat %s"%(self.filesystem_name[index_param]))
+                == init_filesystem_value[index_param]), log.F("FILESYSTEM : parameter update error for %s"
+                                                              %(self.block_name))
+
+    def test_Undefined_Param_Case(self):
+        """
+        Testing error BLOCK_PARAMETER : Out of range TestCase
+        -----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set parameter PARAM_UNDEF to 1
+                - check block parameter Filesystem value
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - Error detected when setting PARAM_UNDEF
+                - FILESYSTEM parameters set to nominal value
+        """
+        log.D(self.test_Undefined_Param_Case.__doc__)
+
+        param_value = "1"
+        param_undefined_name = self.block_name + "/PARAM_UNDEF"
+
+        log.I("Load the initial value of parameters")
+        init_value_param=[]
+        init_filesystem_value=[]
+
+        for index_param in range(len(self.param_name)) :
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            init_value_param.append(out)
+            init_filesystem_value.append(commands.getoutput("cat %s"
+                                                            %(self.filesystem_name[index_param])))
+
+        log.I("set parameter %s to %s, failed expected"
+              %(param_undefined_name,param_value))
+        out,err = self.pfw.sendCmd("setParameter",param_undefined_name,param_value)
+        assert err == None, log.E("setParameter %s %s : %s"
+                                  % (param_undefined_name,param_value, err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s to out of bound value %s"
+                                    % (param_undefined_name,param_value))
+        log.I("Check parameter value")
+        for index_param in range(len(self.param_name)):
+            out,err = self.pfw.sendCmd("getParameter",self.param_name[index_param])
+            assert out == init_value_param[index_param], log.F("BLACKBOARD: Forbidden change value for %s - Expected : %s Found : %s"
+                                                             %(self.param_name[index_param],init_value_param[index_param],out))
+        log.I("Check filesystem value")
+        assert (commands.getoutput("cat %s"%(self.filesystem_name[index_param]))
+                == init_filesystem_value[index_param]), log.F("FILESYSTEM : parameter update error for %s"
+                                                              %(self.block_name))
diff --git a/test/functional-tests/PfwTestCase/Types/tRAW.py b/test/functional-tests/PfwTestCase/Types/tRAW.py
new file mode 100644
index 0000000..6c96bfa
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tRAW.py
@@ -0,0 +1,722 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Raw Value testcases.
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT16_MAX :
+        - 16 bits Unsigned Integer
+        - range [0x0, 0xFFFF]
+    UINT_16 :
+        - 16 bits Unsigned Integer
+        - range [0x0, 0x03E8]
+
+Test cases :
+------------
+    - Testing setValueSpace/getValueSpace functions
+    - Testing setOutputRawFormat/getOutputRawFormat functions
+    - UINT16_max parameter in nominal case = 50 / 0x32 :
+        - Writing Raw / Reading Hex
+        - Writing Raw / Reading Dec
+        - Writing Real / Reading Hex
+    - UINT16_max parameter min value = 0 :
+        - Writing Raw / Reading Hex
+        - Writing Raw / Reading Dec
+        - Writing Real / Reading Hex
+    - UINT16_max parameter max value = 65535 / 0xFFFF :
+        - Writing Raw / Reading Hex
+        - Writing Raw / Reading Dec
+        - Writing Real / Reading Hex
+    - UINT16_max parameter max value out of bounds = 0x10000 :
+        - Writing Raw
+    - UINT16 parameter max value out of bounds = 0x03E9 :
+        - Writing Raw
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT16 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT16_Max"
+        self.filesystem_name="$PFW_FILESYSTEM/UINT16_Max"
+        self.param_name_2 = "/Test/Test/TEST_DIR/UINT16"
+        self.filesystem_name_2="$PFW_FILESYSTEM/UINT16"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+
+    def test_01_SettingOutputRawFormat(self):
+        """
+        Testing RAW - setOutputRawFormat/getOutputRawFormat functions
+        -------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set hex in output raw format
+                - get output raw format
+                - set dec in output raw format
+                - get output raw format
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setOutputRawFormat] function
+                - [getOutputRawFormat] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - getOutputRawFormat return hex after setting hex
+                - getOutputRawFormat return dec after setting dec
+        """
+        log.D(self.test_01_SettingOutputRawFormat.__doc__)
+        value = "hex"
+        log.I("Setting %s in output raw format"
+              %(value))
+        out, err = self.pfw.sendCmd("setOutputRawFormat", value)
+        assert err == None, log.E("When setting output raw format : %s"
+                                  % (err))
+        assert out == "Done", log.F("setOutputRawFormat - expected : Done , found : %s"
+                                    % (out))
+        log.I("Check output raw format state")
+        out, err = self.pfw.sendCmd("getOutputRawFormat","")
+        assert err == None, log.E("When getting output raw format : %s"
+                                  % (err))
+        assert out == value, log.F("getOutputRawFormat - expected : %s , found : %s"
+                                   % (value,out))
+        value = "dec"
+        log.I("Setting %s in output raw format"
+              %(value))
+        out, err = self.pfw.sendCmd("setOutputRawFormat", value)
+        assert err == None, log.E("When setting output raw format : %s"
+                                  % (err))
+        assert out == "Done", log.F("setOutputRawFormat - expected : Done , found : %s"
+                                    % (out))
+        log.I("Check output raw format state")
+        out, err = self.pfw.sendCmd("getOutputRawFormat","")
+        assert err == None, log.E("When getting output raw format : %s"
+                                  % (err))
+        assert out == value, log.F("getOutputRawFormat - expected : %s , found : %s"
+                                   % (value,out))
+
+    def test_02_SettingValueSpace(self):
+        """
+        Testing RAW - setValueSpace/getValueSpace functions
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set raw in value space
+                - get value space
+                - set real in value space
+                - get value space
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setValueSpace] function
+                - [getValueSpace] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - getValueSpace return 'raw' after setting raw
+                - getValueSpace return 'real' after setting real
+        """
+        log.D(self.test_02_SettingValueSpace.__doc__)
+        value = "raw"
+        log.I("Setting %s in value space"
+              % (value))
+        out, err = self.pfw.sendCmd("setValueSpace", value)
+        assert err == None, log.E("When setting value space : %s"
+                                  % (err))
+        assert out == "Done", log.F("setValueSpace - expected : done , found : %s"
+                                    % (out))
+        log.I("check value space state")
+        out, err = self.pfw.sendCmd("getValueSpace","")
+        assert err == None, log.E("When setting value space : %s"
+                                  % (err))
+        assert out == value, log.F("getValueSpace - expected : %s , found : %s"
+                                   % (value,out))
+        value = "real"
+        log.I("Setting %s in value space" % (value))
+        out, err = self.pfw.sendCmd("setValueSpace", value)
+        assert err == None, log.E("When setting value space : %s"
+                                  % (err))
+        assert out == "Done", log.F("setValueSpace - expected : done , found : %s"
+                                    % (out))
+        log.I("check value space state")
+        out, err = self.pfw.sendCmd("getValueSpace","")
+        assert err == None, log.E("When setting value space : %s"
+                                  % (err))
+        assert out == value, log.F("getValueSpace - expected : %s , found : %s"
+                                   % (value,out))
+
+    def test_03_WRaw_RHex_Nominal_Case(self):
+        """
+        Testing RAW - Nominal Case - UINT16_Max - Writing Raw / Reading Hex
+        -------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x32
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x32
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_03_WRaw_RHex_Nominal_Case.__doc__)
+        value = "0xFF00"
+        filesystem_value = "0xFF00"
+        blackboard_value = "0xFF00"
+        value_space = "raw"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              % (self.param_name))
+
+    def test_04_WReal_RHex_Nominal_Case(self):
+        """
+        Testing RAW - Nominal Case - UINT16_Max - Writing Real / Reading Hex
+        --------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x32
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x32
+                - Blackboard and filesystem values checked
+                - When value space setting to Real, Output Raw Format is
+                disabled. Even if Output Raw Format is setting to Hex, the
+                output is in decimal.
+        """
+        log.D(self.test_04_WReal_RHex_Nominal_Case.__doc__)
+        value = "50"
+        filesystem_value = "0x32"
+        blackboard_value = "50"
+        value_space = "real"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+    def test_05_WRaw_RDec_Nominal_Case(self):
+        """
+        Testing RAW - Nominal Case - UINT16_Max - Writing Raw / Reading Dec
+        -------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x32
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x32
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_05_WRaw_RDec_Nominal_Case.__doc__)
+        value = "0x32"
+        filesystem_value = "0x32"
+        blackboard_value = "50"
+        value_space = "raw"
+        outputraw_format = "dec"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+
+
+    def test_06_WRaw_RHex_TypeMin_Case(self):
+        """
+        Testing RAW - Minimum Case - UINT16_Max - Writing Raw / Reading Hex
+        -------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x0
+                - Blackboard and filesystem values checked
+
+        """
+        log.D(self.test_06_WRaw_RHex_TypeMin_Case.__doc__)
+        value = "0x0"
+        filesystem_value = "0x0"
+        blackboard_value = "0x0000"
+        value_space = "raw"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    %(value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+    def test_07_WReal_RHex_TypeMin_Case(self):
+        """
+        Testing RAW - Minimum Case - UINT16_Max - Writing Real / Reading Hex
+        --------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x0
+                - Blackboard and filesystem values checked
+                - When value space setting to Real, Output Raw Format is
+                disabled. Even if Output Raw Format is setting to Hex, the
+                output is in decimal.
+        """
+        log.D(self.test_07_WReal_RHex_TypeMin_Case.__doc__)
+        value = "0"
+        filesystem_value = "0x0"
+        blackboard_value = "0"
+        value_space = "real"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+    def test_08_WRaw_RDec_TypeMin_Case(self):
+        """
+        Testing RAW - Minimum Case - UINT16_Max - Writing raw / Reading dec
+        -------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0x0
+                - Blackboard and filesystem values checked
+                - When value space setting to Real, Output Raw Format is
+                disabled. Even if Output Raw Format is setting to Hex, the
+                output is in decimal.
+        """
+        log.D(self.test_08_WRaw_RDec_TypeMin_Case.__doc__)
+        value = "0x0"
+        filesystem_value = "0x0"
+        blackboard_value = "0"
+        value_space = "raw"
+        outputraw_format = "dec"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+
+    def test_09_WRaw_RHex_TypeMax_Case(self):
+        """
+        Testing RAW - Maximum Case - UINT16_Max - Writing Raw / Reading Hex
+        -------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0xFFFF / 65535
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0xFFFF
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_09_WRaw_RHex_TypeMax_Case.__doc__)
+        value = "0xFFFF"
+        filesystem_value = "0xffff"
+        blackboard_value = "0xFFFF"
+        value_space = "raw"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+    def test_10_WReal_RHex_TypeMax_Case(self):
+        """
+        Testing RAW - Maximum Case - UINT16_Max - Writing Real / Reading Hex
+        --------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0xFFFF / 65535
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0xFFFF
+                - Blackboard and filesystem values checked
+                - When value space setting to Real, Output Raw Format is
+                disabled. Even if Output Raw Format is setting to Hex, the
+                output is in decimal.
+        """
+        log.D(self.test_10_WReal_RHex_TypeMax_Case.__doc__)
+        value = "65535"
+        filesystem_value = "0xffff"
+        blackboard_value = "65535"
+        value_space = "real"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+    def test_11_WRaw_RDec_TypeMax_Case(self):
+        """
+        Testing RAW - Maximum Case - UINT16_Max - Writing Real / Reading Hex
+        --------------------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0xFFFF / 65535
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0xFFFF
+                - Blackboard and filesystem values checked
+                - When value space setting to Real, Output Raw Format is
+                disabled. Even if Output Raw Format is setting to Hex, the
+                output is in decimal.
+        """
+        log.D(self.test_11_WRaw_RDec_TypeMax_Case.__doc__)
+        value = "0xFFFF"
+        filesystem_value = "0xffff"
+        blackboard_value = "65535"
+        value_space = "raw"
+        outputraw_format = "dec"
+
+        log.I("UINT16_Max parameter in nominal case = %s"
+              %(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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("setParameter - Unable to set the value %s for the  parameter %s"
+                                    % (value,self.param_name))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        assert err == None, log.E("When setting parameter %s : %s"
+                                  % (self.param_name, err))
+        assert out == blackboard_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s"
+                                              % (self.param_name, blackboard_value, out))
+        #Check parameter value on filesystem
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, log.F("FILESYSTEM : parameter update error for %s"
+                                                                                              %(self.param_name))
+
+
+    def test_12_WRaw_UINT16_Max_OutOfBound(self):
+        """
+        Testing RAW - Out of range Case - UINT16_Max - Writing Raw
+        ----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x10000 / 65536
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16_max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_12_WRaw_UINT16_Max_OutOfBound.__doc__)
+        value = "0x10000"
+        filesystem_value = commands.getoutput("cat %s"%(self.filesystem_name))
+        value_space = "raw"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter max value out of bound = %s"%(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #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 bound"
+                                    % (self.param_name))
+        #Check parameter value on blackboard
+        assert commands.getoutput("cat %s"%(self.filesystem_name)) == filesystem_value, "FILESYSTEM : Forbiden parameter change"
+
+
+    def test_13_WRaw_UINT16_OutOfBound(self):
+        """
+        Testing RAW - Out of range Case - UINT16 - Writing Raw
+        ------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter in nominal case = 0x03E9 / 1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+                - [setValueSpace] function
+                - [setOutputRawFormat] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_13_WRaw_UINT16_OutOfBound.__doc__)
+        value = "0x03E9"
+        filesystem_value = commands.getoutput("cat %s"%(self.filesystem_name_2))
+        value_space = "raw"
+        outputraw_format = "hex"
+
+        log.I("UINT16_Max parameter max value out of bound = %s"%(value))
+        log.I("Value space = %s - Output Raw Format = %s"
+              %(value_space,outputraw_format))
+        self.pfw.sendCmd("setValueSpace", value_space)
+        self.pfw.sendCmd("setOutputRawFormat", outputraw_format)
+        #Set parameter value
+        out, err = self.pfw.sendCmd("setParameter", self.param_name_2, value)
+        assert err == None, log.E("when setting parameter %s -> %s"
+                                  % (self.param_name_2, err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s out of bound"
+                                    % (self.param_name_2))
+        #Check parameter value on blackboard
+        assert commands.getoutput("cat %s"%(self.filesystem_name_2)) == filesystem_value, "FILESYSTEM : Forbiden parameter change"
diff --git a/test/functional-tests/PfwTestCase/Types/tSTRING_128.py b/test/functional-tests/PfwTestCase/Types/tSTRING_128.py
new file mode 100644
index 0000000..6ef1876
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tSTRING_128.py
@@ -0,0 +1,290 @@
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import commands, string, random
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT8_S - range [-100, 100]
+class TestCases(PfwTestCase):
+
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/STR_CHAR128"
+        self.pfw.sendCmd("setTuningMode", "on")
+        self.size_max=128
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Digits_String_Case(self):
+        """
+        |============================================================|
+        | Testing data types - String                                |
+        |                      max number of char = 128              |
+        |============================================================|
+        | File    : tSTRING_128.py                                   |
+        | Version : 01                                               |
+        |                                                            |
+        | Test cases :                                               |
+        | - STR_CHAR128 parameter nominal value = string_Conf_0      |
+        | - STR_CHAR128 parameter empty value = ''                   |
+        | - STR_CHAR128 parameter full value = generate randomly 128 |
+        | letters characters                                         |
+        | - STR_CHAR128 parameter space character value = test string|
+        | - STR_CHAR128 parameter full digits value = generate       |
+        | randomly 128 digits char                                   |
+        | - STR_CHAR128 parameter oversize value = generate randomly |
+        | 129 char                                                   |
+        |                                                            |
+        |============================================================|
+        | STR_CHAR128 parameter in digits case = 128 digits char     |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter in digit case = 128 digits char    |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - STR_CHAR128 parameter set to the same 128 digits char    |
+        |   (blackboard and filesystem values checked)               |
+        |============================================================|
+        """
+        log.D(self.test_Digits_String_Case.__doc__)
+        log.I("STR_CHAR128 parameter initial state = string_Conf_0")
+        value = ""
+        for i in range(self.size_max-1):
+            value=value+str(random.choice(string.digits))
+        #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(out)
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+
+    def test_Empty_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter empty string = \'\'                    |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter in empty string case = \'\'          |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - STR_CHAR128 parameter set empty                          |
+        |   (blackboard and filesystem values checked)               |
+        |============================================================|
+        """
+        log.D(self.test_Empty_String_Case.__doc__)
+        log.I("STR_CHAR128 parameter empty string = \'\'")
+        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(out)
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+
+    def test_OverSize_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter oversize                             |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter in oversize case = 129 random char |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - error detected                                           |
+        | - STR_CHAR128 parameter not updated                        |
+        |============================================================|
+        """
+        log.D(self.test_OverSize_String_Case.__doc__)
+        log.I("STR_CHAR128 parameter size max=128 character")
+        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')
+        #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")
+
+    def test_Full_Letters_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter full size test case                  |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter in fullsize case = 128 random char |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - STR_CHAR128 parameter set to the same 128 letters char   |
+        |   (blackboard and filesystem values checked)               |
+        |============================================================|
+        """
+        log.D(self.test_Full_Letters_String_Case.__doc__)
+        log.I("STR_CHAR128 parameter initial state : string")
+        value = ""
+        for i in range(self.size_max-1):
+            value=value+str(random.choice(string.letters))
+        #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("Expected : Done, result : %s" % (out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+
+    def test_Nominal_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter Nominal test case                    |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter in nominal case = TestString       |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - STR_CHAR128 parameter set to TestString                  |
+        |   (blackboard and filesystem values checked)               |
+        |============================================================|
+        """
+        log.D(self.test_Nominal_String_Case.__doc__)
+        log.I("STR_CHAR128 parameter nominal string = TestString")
+        value = "TestString"
+        #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("Expected : Done, found : %s" % (out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
+
+    def test_Punctuation_Empty_Parenthese_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter empty Parenthese char test case      |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter = TestParenthese()                 |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - Not Determined now                                       |
+        |============================================================|
+        """
+        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')
+        #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 == 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")
+
+    def test_Punctuation_Full_Parenthese_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter full Parenthese char test case       |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter = TestParenthese(test)             |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - Not Determined now                                       |
+        |============================================================|
+        """
+        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')
+        #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 == 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")
+
+    def test_SpaceChar_String_Case(self):
+        """
+        |============================================================|
+        | STR_CHAR128 parameter space char test case                 |
+        |============================================================|
+        | Test Case description :                                    |
+        | - STR_CHAR128 parameter = Test String                      |
+        | Tested commands :                                          |
+        | * setParameter                                             |
+        | - getParameter                                             |
+        | Expected result :                                          |
+        | - Not Determined now                                       |
+        |============================================================|
+        """
+        log.D(self.test_SpaceChar_String_Case.__doc__)
+        value = "Test String"
+        log.I("STR_CHAR128 parameter Parenthese Char = %s" % (value))
+        value_check = "Test String"
+        #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("Expected : Done, found : %s" % (out))
+       #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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")
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT16.py b/test/functional-tests/PfwTestCase/Types/tUINT16.py
new file mode 100644
index 0000000..5be2189
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT16.py
@@ -0,0 +1,249 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""
+Integer parameter type testcases - UINT16
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT16 :
+        - unsigned
+        - size = 16
+        - range : [0, 1000]
+
+Test cases :
+------------
+    - UINT16 parameter min value = 0
+    - UINT16 parameter min value out of bounds = -1
+    - UINT16 parameter max value = 1000
+    - UINT16 parameter max value out of bounds = 1001
+    - UINT16 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of type UINT16 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT16"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT16 in nominal case = 50
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT16 parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT16 minimal value = 0
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT16 parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT16 parameter value out of negative range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT16') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT16 parameter maximum value
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to 1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 1000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT16 parameter max value = 1000")
+        value = "1000"
+        hex_value = "0x3e8"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT16 parameter value out of positive range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to 1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..30f25a9
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT16_Max.py
@@ -0,0 +1,248 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - UINT16_Max
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT16_Max :
+        - unsigned
+        - size = 16
+        - range : [0, 65535]
+
+Test cases :
+------------
+    - UINT16_Max parameter min value = 0
+    - UINT16_Max parameter min value out of bounds = -1
+    - UINT16_Max parameter max value = 65535
+    - UINT16_Max parameter max value out of bounds = 65536
+    - UINT16_Max parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of type UINT16_Max - range [0, 65535]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT16_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT16_Max in nominal case = 50
+        ---------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16_Max parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT16_Max parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT16_Max minimal value = 0
+        ------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16_Max parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT16_Max parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT16_Max parameter value out of negative range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16_Max to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT16_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT16_Max parameter maximum value
+        ------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16_Max to 65535
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16_Max parameter set to 65535
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT16_Max parameter max value = 65535")
+        value = "65535"
+        hex_value = "0xffff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT16_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT16_Max parameter value out of positive range
+        --------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16_Max to 65536
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..662fe9a
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32.py
@@ -0,0 +1,248 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - UINT32
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT32 :
+        - unsigned
+        - size = 32
+        - range : [0, 1000]
+
+Test cases :
+------------
+    - UINT32 parameter min value = 0
+    - UINT32 parameter min value out of bounds = -1
+    - UINT32 parameter max value = 1000
+    - UINT32 parameter max value out of bounds = 1001
+    - UINT32 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of type UINT32 - range [0, 1000]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT32"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT32 in nominal case = 50
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT32 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT32 parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT32 minimal value = 0
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT32 parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32 parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT32 parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT32 parameter value out of negative range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT32 to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT32 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT32') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT32 parameter maximum value
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT32 to 1000
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32 parameter set to 1000
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT32 parameter max value = 1000")
+        value = "1000"
+        hex_value = "0x3e8"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT32 parameter value out of positive range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT32 to 1001
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT32 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..ce584ac
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py
@@ -0,0 +1,324 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Array parameter type testcases : UINT32 Array
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT8 Array = 32bits unsigned int array :
+        - Array size : 10
+        - values range : [0, 100]
+
+Test cases :
+------------
+    - Testing nominal case
+    - Testing minimum
+    - Testing minimum overflow
+    - Testing maximum
+    - Testing maximum overflow
+    - Testing array index out of bounds
+    - Testing value format error
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+from ctypes import c_uint16
+
+
+class TestCases(PfwTestCase):
+
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT32_ARRAY"
+        self.param_short_name = "$PFW_FILESYSTEM/UINT32_ARRAY"
+        print '\r'
+        self.pfw.sendCmd("setTuningMode", "on")
+        print '\r'
+        self.array_size = 10
+        self.array_min = 0
+        self.array_max = 100
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT32_ARRAY Nominal Case
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT32_ARRAY elements to autorized values
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+
+        for index in range (self.array_size):
+            indexed_array_value = index + self.array_min
+            if indexed_array_value>self.array_max:
+                indexed_array_value=self.array_max
+            hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+            #Check parameter value setting
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                      % (self.param_name, str(index), err))
+            assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                        % (self.param_name, str(index), out))
+            #Check parameter value on blackboard
+            out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+            assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                      % (self.param_name, str(index), err))
+            assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                          % (self.param_name, str(index), str(indexed_array_value), out))
+            #Check parameter value on filesystem
+            files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+            indexed_files_system_array_value = commands.getoutput(files_system_check)
+            assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                      % (self.param_name, str(index)))
+
+    def test_Min_Value(self):
+        """
+        Testing UINT32_ARRAY minimum value
+        ----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT32_ARRAY elements to minimum values : 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Min_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Min_Value_Overflow(self):
+        """
+        Testing UINT32_ARRAY parameter values out of negative range
+        -----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT32_ARRAY elements to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Min_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value - 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Max_Value(self):
+        """
+        Testing UINT32_ARRAY maximum value
+        ----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT32_ARRAY elements to maximum values : 15
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Max_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Max_Value_Overflow(self):
+        """
+        Testing UINT32_ARRAY parameter values out of positive range
+        -----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT32_ARRAY elements to 16
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Max_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value + 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Array_Index_Overflow(self):
+        """
+        Testing Array index out of bounds
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set an out of bounds array indexed element
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT32_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Array_Index_Overflow.__doc__)
+        index_values = (self.array_size-1, self.array_size+1, -1)
+        for index in index_values:
+            print index
+            indexed_array_value = self.array_max
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            #Check parameter value setting
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            if index in [0, self.array_size-1]:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), out))
+            else:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out != "Done", log.F("Error not detected when setting array %s index out of bounds"
+                                            % (self.param_name))
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py b/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py
new file mode 100644
index 0000000..b99dd1b
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT32_Max.py
@@ -0,0 +1,248 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - UINT16
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT16 :
+        - unsigned
+        - size = 32
+        - range : [0, 4294967295]
+
+Test cases :
+------------
+    - UINT16 parameter min value = 0
+    - UINT16 parameter min value out of bounds = -1
+    - UINT16 parameter max value = 4294967295
+    - UINT16 parameter max value out of bounds = 4294967296
+    - UINT16 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of type UINT32_Max - range [0, 4294967295]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT32_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT16 in nominal case = 50
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT32_Max parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT16 minimal value = 0
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT32_Max parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT16 parameter value out of negative range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT32_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT16 parameter maximum value
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to 4294967295
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT16 parameter set to 4294967295
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT32_Max parameter max value = 4294967295")
+        value = "4294967295"
+        hex_value = "0xffffffff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT32_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT16 parameter value out of positive range
+        ----------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT16 to 4294967296
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT16 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..d65a44e
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8.py
@@ -0,0 +1,247 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - UINT8
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT8 :
+        - unsigned
+        - size = 8
+        - range : [0, 100]
+
+Test cases :
+------------
+    - UINT8 parameter min value = 0
+    - UINT8 parameter min value out of bounds = -1
+    - UINT8 parameter max value = 100
+    - UINT8 parameter max value out of bounds = 101
+    - UINT8 parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of type UINT8 - range [0, 100]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT8"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT8 in nominal case = 50
+        ----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8 parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8 parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT8 parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT8 minimal value = 0
+        -------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8 parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8 parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT8 parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT8 parameter value out of negative range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8 to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT8 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT8') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT8 parameter maximum value
+        -------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8 to 100
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8 parameter set to 100
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT8 parameter max value = 100")
+        value = "100"
+        hex_value = "0x64"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT8 parameter value out of positive range
+        ---------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8 to 101
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT8 parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/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
new file mode 100644
index 0000000..9f82a36
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py
@@ -0,0 +1,376 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Array parameter type testcases : UINT8 Array
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT8 Array = 8bits unsigned int array :
+        - Array size : 5
+        - values range : [0, 15]
+
+Test cases :
+------------
+    - Testing nominal case
+    - Testing minimum
+    - Testing minimum overflow
+    - Testing maximum
+    - Testing maximum overflow
+    - Testing array index out of bounds
+    - Testing value format error
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+from ctypes import c_uint16
+
+
+class TestCases(PfwTestCase):
+
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT8_ARRAY"
+        self.param_short_name = "$PFW_FILESYSTEM/UINT8_ARRAY"
+        print '\r'
+        self.pfw.sendCmd("setTuningMode", "on")
+        print '\r'
+        self.array_size = 5
+        self.array_min = 0
+        self.array_max = 15
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT8_ARRAY Nominal Case
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT8_ARRAY elements to autorized values
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+
+        for index in range (self.array_size):
+            indexed_array_value = index + self.array_min
+            if indexed_array_value>self.array_max:
+                indexed_array_value=self.array_max
+            hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+            #Check parameter value setting
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                      % (self.param_name, str(index), err))
+            assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                        % (self.param_name, str(index), out))
+            #Check parameter value on blackboard
+            out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+            assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                      % (self.param_name, str(index), err))
+            assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                          % (self.param_name, str(index), str(indexed_array_value), out))
+            #Check parameter value on filesystem
+            files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+            indexed_files_system_array_value = commands.getoutput(files_system_check)
+            assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                      % (self.param_name, str(index)))
+
+    def test_Min_Value(self):
+        """
+        Testing UINT8_ARRAY minimum value
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT8_ARRAY elements to minimum values : 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Min_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Min_Value_Overflow(self):
+        """
+        Testing UINT8_ARRAY parameter values out of negative range
+        ----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT8_ARRAY elements to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Min_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_min
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value - 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Max_Value(self):
+        """
+        Testing UINT8_ARRAY maximum value
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT8_ARRAY elements to maximum values : 15
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements correctly recorded
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Max_Value.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        hex_indexed_array_value = hex(c_uint16(indexed_array_value).value)
+        #Check parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", str(indexed_array_value_path), "")
+        assert err == None, log.E("when setting parameter %s[%s] : %s"
+                                  % (self.param_name, str(index), err))
+        assert out == str(indexed_array_value), log.F("BLACKBOARD : Incorrect value for %s[%s], expected: %s, found: %s"
+                                                      % (self.param_name, str(index), str(indexed_array_value), out))
+        #Check parameter value on filesystem
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == hex_indexed_array_value, log.F("FILESSYSTEM : %s[%s] update error"
+                                                                                  % (self.param_name, str(index)))
+
+    def test_Max_Value_Overflow(self):
+        """
+        Testing UINT8_ARRAY parameter values out of positive range
+        ----------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set every UINT8_ARRAY elements to 16
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Max_Value_Overflow.__doc__)
+        index = 0
+        indexed_array_value = self.array_max
+        indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        files_system_check = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check = commands.getoutput(files_system_check)
+        #Check final parameter value setting
+        indexed_array_value = indexed_array_value + 1
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out != "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                                    % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value = commands.getoutput(files_system_check)
+        assert indexed_files_system_array_value == param_check, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                      % (self.param_name, str(index)))
+
+    def test_Array_Index_Overflow(self):
+        """
+        Testing Array index out of bounds
+        ---------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Set an out of bounds array indexed element
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Array_Index_Overflow.__doc__)
+        index_values = (self.array_size-1, self.array_size+1, -1)
+        for index in index_values:
+            print index
+            indexed_array_value = self.array_max
+            indexed_array_value_path = "".join([self.param_name, "/", str(index)])
+            #Check parameter value setting
+            out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path), str(indexed_array_value))
+            if index in [0, self.array_size-1]:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), out))
+            else:
+                assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                          % (self.param_name, str(index), err))
+                assert out != "Done", log.F("Error not detected when setting array %s index out of bounds"
+                                            % (self.param_name))
+
+    def test_Value_Format_Error(self):
+        """
+        Testing Array value format error
+        --------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - Trying to write an int16 into an 8 bits array element
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_ARRAY array elements not recorded
+                - Error correctly detected
+        """
+        log.D(self.test_Value_Format_Error.__doc__)
+        index = 0
+        var_uint16 = c_uint16(5).value
+        indexed_array_value_1 = 0
+        indexed_array_value_2 = 10
+        indexed_array_value_path_1 = "".join([self.param_name, "/", str(index)])
+        indexed_array_value_path_2 = "".join([self.param_name, "/", str(index+1)])
+        #Check initial parameter value setting
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path_1), str(indexed_array_value_1))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index), out))
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path_2), str(indexed_array_value_2))
+        assert err == None, log.E("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index+1), err))
+        assert out == "Done", log.F("when setting parameter %s[%s]: %s"
+                                  % (self.param_name, str(index+1), out))
+        files_system_check_1 = "awk -v ligne="+str(index)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check_1 = commands.getoutput(files_system_check_1)
+        files_system_check_2 = "awk -v ligne="+str(index+1)+" 'NR == ligne+1 { print $0}' "+self.param_short_name
+        param_check_2 = commands.getoutput(files_system_check_2)
+        #Check final parameter value setting (!= or == ?)
+        out, err = self.pfw.sendCmd("setParameter", str(indexed_array_value_path_1), str(var_uint16))
+        assert err == None, log.E("Error when setting parameter %s[%s]: %s"
+                           % (self.param_name, str(index), err))
+        ### TBC : check expected result ###
+        assert out == "Done", log.F("Error not detected when setting parameter %s[%s] out of bounds"
+                             % (self.param_name, str(index)))
+        #Check parameter value on filesystem
+        indexed_files_system_array_value_2 = commands.getoutput(files_system_check_2)
+        assert indexed_files_system_array_value_2 == param_check_2, log.F("FILESSYSTEM : %s[%s] forbiden update"
+                                                                          % (self.param_name, str(index)))
diff --git a/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py b/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py
new file mode 100644
index 0000000..1d6b47a
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Types/tUINT8_Max.py
@@ -0,0 +1,248 @@
+#!/usr/bin/python2
+# -*-coding:utf-8 -*
+
+# Copyright (c) 2011-2015, Intel Corporation
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation and/or
+# other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+# may be used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Integer parameter type testcases - UINT8_Max
+
+List of tested functions :
+--------------------------
+    - [setParameter]  function
+    - [getParameter] function
+
+Initial Settings :
+------------------
+    UINT8_Max :
+        - unsigned
+        - size = 8
+        - range : [0, 255]
+
+Test cases :
+------------
+    - UINT8_Max parameter min value = 0
+    - UINT8_Max parameter min value out of bounds = -1
+    - UINT8_Max parameter max value = 255
+    - UINT8_Max parameter max value out of bounds = 256
+    - UINT8_Max parameter in nominal case = 50
+"""
+import commands
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of type UINT8_Max - range [0, 255]
+class TestCases(PfwTestCase):
+    def setUp(self):
+        self.param_name = "/Test/Test/TEST_DIR/UINT8_Max"
+        self.pfw.sendCmd("setTuningMode", "on")
+
+    def tearDown(self):
+        self.pfw.sendCmd("setTuningMode", "off")
+
+    def test_Nominal_Case(self):
+        """
+        Testing UINT8_Max in nominal case = 50
+        --------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8_Max parameter in nominal case = 50
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_Max parameter set to 50
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_Nominal_Case.__doc__)
+        log.I("UINT8_Max parameter in nominal case = 50")
+        value = "50"
+        hex_value = "0x32"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin(self):
+        """
+        Testing UINT8_Max minimal value = 0
+        -----------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8_Max parameter min value = 0
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_Max parameter set to 0
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMin.__doc__)
+        log.I("UINT8_Max parameter min value = 0")
+        value = "0"
+        hex_value = "0x0"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMin_Overflow(self):
+        """
+        Testing UINT8_Max parameter value out of negative range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8_Max to -1
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT8_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")
+
+    def test_TypeMax(self):
+        """
+        Testing UINT8_Max parameter maximum value
+        -----------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8_Max to 255
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - UINT8_Max parameter set to 255
+                - Blackboard and filesystem values checked
+        """
+        log.D(self.test_TypeMax.__doc__)
+        log.I("UINT8_Max parameter max value = 255")
+        value = "255"
+        hex_value = "0xff"
+        #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("when setting parameter %s : %s"
+                                  % (self.param_name, out))
+        #Check parameter value on blackboard
+        out, err = self.pfw.sendCmd("getParameter", self.param_name, "")
+        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/UINT8_Max') == hex_value, log.F("FILESYSTEM : parameter update error")
+        log.I("test OK")
+
+    def test_TypeMax_Overflow(self):
+        """
+        Testing UINT8_Max parameter value out of positive range
+        -------------------------------------------------------
+            Test case description :
+            ~~~~~~~~~~~~~~~~~~~~~~~
+                - set UINT8_Max to 256
+            Tested commands :
+            ~~~~~~~~~~~~~~~~~
+                - [setParameter] function
+            Used commands :
+            ~~~~~~~~~~~~~~~
+                - [getParameter] function
+            Expected result :
+            ~~~~~~~~~~~~~~~~~
+                - error detected
+                - UINT8_Max parameter not updated
+                - Blackboard and filesystem values checked
+        """
+        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')
+        #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/UINT8_Max') == param_check, log.F("FILESYSTEM : Forbiden parameter change")
+        log.I("test OK")