summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
authorJules Clero <julesx.clero@intel.com>2015-02-18 18:04:39 +0100
committerEric Laurent <elaurent@google.com>2015-04-24 13:39:12 -0700
commitc4cc78f87e10cd3ac61f936b1c2ee3d11e9b9d02 (patch)
tree750df1de30e43327ec9a594890ec728882ea1162 /test
parent4e5e78b2c3669d308003713e758d6b3a59d50b0c (diff)
downloadexternal_parameter-framework-c4cc78f87e10cd3ac61f936b1c2ee3d11e9b9d02.zip
external_parameter-framework-c4cc78f87e10cd3ac61f936b1c2ee3d11e9b9d02.tar.gz
external_parameter-framework-c4cc78f87e10cd3ac61f936b1c2ee3d11e9b9d02.tar.bz2
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>
Diffstat (limited to 'test')
-rwxr-xr-xtest/functional-tests/ACTCampaignEngine.py67
-rw-r--r--test/functional-tests/PfwTestCase/Domains/__init__.py10
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Configuration.py505
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Backup.py239
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Selection.py185
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Elements.py311
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Elements_Sequences.py294
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Rules.py443
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_Split.py247
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_creation_deletion.py344
-rw-r--r--test/functional-tests/PfwTestCase/Domains/tDomain_rename.py337
-rw-r--r--test/functional-tests/PfwTestCase/Functions/__init__.py9
-rw-r--r--test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py1143
-rw-r--r--test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py250
-rw-r--r--test/functional-tests/PfwTestCase/Functions/tFunction_getParameter.py76
-rw-r--r--test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py597
-rw-r--r--test/functional-tests/PfwTestCase/Functions/tFunction_setParameter.py90
-rw-r--r--test/functional-tests/PfwTestCase/Types/__init__.py32
-rw-r--r--test/functional-tests/PfwTestCase/Types/tBit_Block.py319
-rw-r--r--test/functional-tests/PfwTestCase/Types/tBoolean.py161
-rw-r--r--test/functional-tests/PfwTestCase/Types/tEnum.py265
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP16_Q0_15.py232
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP16_Q15_0.py230
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP16_Q7_8.py235
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP32_Q0_31.py236
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP32_Q15_16.py238
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP32_Q31_0.py246
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP32_Q8_20.py244
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP8_Q0_7.py248
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP8_Q3_4.py247
-rwxr-xr-xtest/functional-tests/PfwTestCase/Types/tFP8_Q7_0.py247
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT16.py245
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT16_ARRAY.py323
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT16_Max.py245
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT32.py229
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT32_Max.py244
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT8.py245
-rw-r--r--test/functional-tests/PfwTestCase/Types/tINT8_Max.py229
-rw-r--r--test/functional-tests/PfwTestCase/Types/tParameter_Block.py290
-rw-r--r--test/functional-tests/PfwTestCase/Types/tRAW.py722
-rw-r--r--test/functional-tests/PfwTestCase/Types/tSTRING_128.py290
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT16.py249
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT16_Max.py248
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT32.py248
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT32_ARRAY.py324
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT32_Max.py248
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT8.py247
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT8_ARRAY.py376
-rw-r--r--test/functional-tests/PfwTestCase/Types/tUINT8_Max.py248
-rw-r--r--test/functional-tests/PfwTestCase/__init__.py0
-rw-r--r--test/functional-tests/Util/ACTLogging.py48
-rw-r--r--test/functional-tests/Util/PfwUnitTestLib.py110
-rw-r--r--test/functional-tests/Util/__init__.py0
-rw-r--r--test/functional-tests/xml/TestConfigurableDomains.xml141
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_Compliant.xml182
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_Criteria.xml182
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_Split_Domain.xml166
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_dumpDomains12
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_dumpDomains.xml62
-rw-r--r--test/functional-tests/xml/XML_Test/Reference_dumpElement89
-rw-r--r--test/functional-tests/xml/XML_Test/Uncompliant_OutboundParameter.xml102
-rw-r--r--test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredConfigurableElement.xml102
-rw-r--r--test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredParameter.xml104
-rw-r--r--test/functional-tests/xml/XML_Test/Uncompliant_UnorderConfigurableElement.xml102
-rw-r--r--test/functional-tests/xml/configuration/ParameterFrameworkConfiguration.xml12
-rw-r--r--test/functional-tests/xml/configuration/Settings/Test/TestConfigurableDomains.xml141
-rw-r--r--test/functional-tests/xml/configuration/Structure/Test/TestClass.xml4
-rw-r--r--test/functional-tests/xml/configuration/Structure/Test/TestSubsystem.xml84
68 files changed, 15220 insertions, 0 deletions
diff --git a/test/functional-tests/ACTCampaignEngine.py b/test/functional-tests/ACTCampaignEngine.py
new file mode 100755
index 0000000..6d39436
--- /dev/null
+++ b/test/functional-tests/ACTCampaignEngine.py
@@ -0,0 +1,67 @@
+#!/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.
+
+"""
+Create a test suite for all tests about SET/GET commands
+
+Uses PfwSetTsetSuite to create a single instance of the HAL
+for all the SET/GEt commands.
+
+These commands are tested using the methods of the classes
+"BooleanTestCase", etc...
+"""
+
+import sys
+import unittest
+from Util import PfwUnitTestLib
+
+class Logger(object):
+
+ def __init__(self, filename="Default.log"):
+ self.terminal = sys.stdout
+ self.log = open(filename, "a")
+
+ def write(self, message):
+ self.terminal.write(message)
+ self.log.write(message)
+
+def testsRunner(testDirectory):
+
+ tests = unittest.defaultTestLoader.discover(testDirectory, pattern='t*.py')
+ runner = unittest.TextTestRunner(verbosity=2)
+
+ return runner.run(tests).wasSuccessful()
+
+def main():
+ sys.exit(not testsRunner('PfwTestCase'))
+
+if __name__ == "__main__":
+ main()
diff --git a/test/functional-tests/PfwTestCase/Domains/__init__.py b/test/functional-tests/PfwTestCase/Domains/__init__.py
new file mode 100644
index 0000000..e49f417
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/__init__.py
@@ -0,0 +1,10 @@
+"""
+Domains Package : All testcases about DOMAINS functions in PFW :
+ - domains configuration selections and restore
+ - domains creation and deletion
+ - domain rename
+ - rules management
+ - elements management
+ - elements sequences in domains
+ - domains split
+""" \ No newline at end of file
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration.py
new file mode 100644
index 0000000..e5fcfed
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration.py
@@ -0,0 +1,505 @@
+# -*-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.
+
+"""
+Creation, renaming and deletion configuration testcases
+
+List of tested functions :
+--------------------------
+ - [listConfigurations] function
+ - [createConfiguration] function
+ - [deleteConfiguration] function
+ - [renameConfiguration] function
+
+Test cases :
+------------
+ - Testing configuration creation error
+ - Testing configuration renaming error
+ - Testing configuration deletion error
+ - Testing nominal case
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+
+# Test of Domains - Rename
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "domain_test"
+ self.conf_test = "conf_white"
+ self.conf_test_renamed = "conf_black"
+ self.new_conf_number = 5
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Conf_Creation_Error(self):
+ """
+ Testing configuration creation error
+ ------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Create an already existent configuration
+ - Create a configuration with no name specified
+ - Create a configuration on a wrong domain name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [createConfiguration] function
+ - [createDomain] function
+ - [listConfigurations] function
+ - [deleteConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - no configuration created
+ - existent configurations not affected by error
+ """
+ log.D(self.test_Conf_Creation_Error.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ for iteration in range (self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ log.I("New configuration %s creation for domain %s" % (new_conf_name,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,new_conf_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (new_conf_name)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (new_conf_name,self.domain_name))
+
+ # Domain configurations listing backup
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations_backup = open("f_configurations_backup", "w")
+ f_configurations_backup.write(out)
+ f_configurations_backup.close()
+
+ # New configurations creation error
+ log.I("Creating an already existent configurations names")
+ for iteration in range (self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ log.I("Trying to create already existent %s configuration for domain %s" % (new_conf_name,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,new_conf_name)
+ assert out != "Done", "ERROR : command [createConfiguration] - Error not detected while creating already existent configuration %s" % (new_conf_name)
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (new_conf_name)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("error correctly detected, no configuration created")
+ log.I("Creating a configuration without specifying a name")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name)
+ assert out != "Done", "ERROR : command [createConfiguration] - Error not detected while creating a configuration without specifying a name"
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration"
+ log.I("error correctly detected")
+ log.I("Creating a configuration on a wrong domain name")
+ new_conf_name = "new_conf"
+ out, err = self.pfw.sendCmd("createConfiguration","wrong_domain_name",new_conf_name)
+ assert out != "Done", "ERROR : command [createConfiguration] - Error not detected while creating a configuration on a wrong domain name"
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration"
+ log.I("error correctly detected")
+
+ # New domain configurations listing
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]" )
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations = open("f_configurations", "w")
+ f_configurations.write(out)
+ f_configurations.close()
+
+ # Checking configurations names integrity
+ log.I("Configurations listing conformity check")
+ f_configurations = open("f_configurations", "r")
+ f_configurations_backup = open("f_configurations_backup", "r")
+ for iteration in range(self.new_conf_number):
+ listed_conf_backup = f_configurations_backup.readline().strip('\n')
+ listed_conf = f_configurations.readline().strip('\n')
+ assert listed_conf==listed_conf_backup, "ERROR : Error while listing configuration %s (found %s)" % (listed_conf_backup, listed_conf)
+ log.I("No change detected, listed configurations names conform to expected values")
+
+ # New domain deletion
+ log.I("End of test, new domain deletion")
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [deleteDomain] - Error while deleting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+
+ # Closing and deleting temp files
+ f_configurations_backup.close()
+ os.remove("f_configurations_backup")
+ f_configurations.close()
+ os.remove("f_configurations")
+
+ def test_Conf_Renaming_Error(self):
+ """
+ Testing configuration renaming error
+ ------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Rename a configuration with an already used name
+ - Rename a configuration with no name specified
+ - Rename a configuration on a wrong domain name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [renameConfiguration] function
+ - [createDomain] function
+ - [listConfigurations] function
+ - [createConfiguration] function
+ - [deleteConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - error detected
+ - no configuration created
+ - existent configurations not affected by error
+ """
+ log.D(self.test_Conf_Renaming_Error.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ for iteration in range (self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ log.I("New configuration %s creation for domain %s" % (new_conf_name,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,new_conf_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (new_conf_name)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (new_conf_name,self.domain_name))
+
+ # Domain configurations listing backup
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations_backup = open("f_configurations_backup", "w")
+ f_configurations_backup.write(out)
+ f_configurations_backup.close()
+
+ # New configurations renaming error
+ log.I("renaming a configuration with an already used name")
+ for iteration in range (self.new_conf_number-1):
+ conf_name = "".join([self.conf_test, "_", str(iteration)])
+ new_conf_name = "".join([self.conf_test, "_", str(iteration+1)])
+ log.I("Trying to rename %s on domain %s with an already used name : %s" % (conf_name,self.domain_name,new_conf_name))
+ log.I("command [renameConfiguration]" )
+ out, err = self.pfw.sendCmd("renameConfiguration",self.domain_name,conf_name,new_conf_name)
+ assert out != "Done", "ERROR : command [renameConfiguration] - Error not detected while renaming configuration %s with an already used name" % (new_conf_name)
+ assert err == None, "ERROR : command [renameConfiguration] - Error while renaming configuration %s" % (new_conf_name)
+ log.I("command [renameConfiguration] correctly executed")
+ log.I("error correctly detected, no configuration renamed")
+ log.I("renaming a configuration without specifying a new name")
+ out, err = self.pfw.sendCmd("renameConfiguration",self.domain_name,new_conf_name)
+ assert out != "Done", "ERROR : command [renameConfiguration] - Error not detected while renaming a configuration without specifying a new name"
+ assert err == None, "ERROR : command [renameConfiguration] - Error while renaming configuration"
+ log.I("error correctly detected, no configuration renamed")
+ log.I("renaming a configuration on a wrong domain name")
+ new_conf_name = "new_conf"
+ out, err = self.pfw.sendCmd("renameConfiguration","wrong_domain_name",new_conf_name,"Configuration")
+ assert out != "Done", "ERROR : command [renameConfiguration] - Error not detected while renaming a configuration on a wrong domain name"
+ assert err == None, "ERROR : command [renameConfiguration] - Error while renaming configuration"
+ log.I("error correctly detected, no configuration renamed")
+
+ # New domain configurations listing
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations = open("f_configurations", "w")
+ f_configurations.write(out)
+ f_configurations.close()
+
+ # Checking configurations names integrity
+ log.I("Configurations listing conformity check")
+ f_configurations = open("f_configurations", "r")
+ f_configurations_backup = open("f_configurations_backup", "r")
+ for iteration in range(self.new_conf_number):
+ listed_conf_backup = f_configurations_backup.readline().strip('\n')
+ listed_conf = f_configurations.readline().strip('\n')
+ assert listed_conf==listed_conf_backup, "ERROR : Error while listing configuration %s (found %s)" % (listed_conf_backup, listed_conf)
+ log.I("No change detected, listed configurations names conform to expected values")
+
+ # Testing domain deletion
+ log.I("End of test, new domain deletion")
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [deleteDomain] - Error while deleting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+
+ # Closing and deleting temp files
+ f_configurations_backup.close()
+ os.remove("f_configurations_backup")
+ f_configurations.close()
+ os.remove("f_configurations")
+
+ def test_Conf_Deletion_Error(self):
+ """
+ Testing configuration deletion error
+ ------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Delete a configuration with a non existent name
+ - Delete a configuration with no name specified
+ - Delete a configuration on a wrong domain name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [deleteConfiguration] function
+ - [createDomain] function
+ - [listConfigurations] function
+ - [createConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - error detected
+ - no configuration created
+ - existent configurations not affected by error
+ """
+ print self.test_Conf_Renaming_Error.__doc__
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ for iteration in range (self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ log.I("New configuration %s creation for domain %s" % (new_conf_name,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,new_conf_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (new_conf_name)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (new_conf_name,self.domain_name))
+
+ # Domain configurations listing backup
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations_backup = open("f_configurations_backup", "w")
+ f_configurations_backup.write(out)
+ f_configurations_backup.close()
+
+ # Configurations deletion errors
+ log.I("Trying various deletions error test cases")
+ log.I("Trying to delete a wrong configuration name on domain %s" % (self.domain_name))
+ log.I("command [deleteConfiguration]")
+ out, err = self.pfw.sendCmd("deleteConfiguration",self.domain_name,"wrong_configuration_name")
+ assert out != "Done", "ERROR : command [deleteConfiguration] - Error not detected while deleting non existent configuration name"
+ assert err == None, "ERROR : command [deleteConfiguration] - Error while deleting configuration"
+ log.I("command [deleteConfiguration] correctly executed")
+ log.I("error correctly detected, no configuration deleted")
+ log.I("deleting a configuration with no name specified")
+ out, err = self.pfw.sendCmd("deleteConfiguration",self.domain_name)
+ assert out != "Done", "ERROR : command [deleteConfiguration] - Error not detected while deleting a configuration without specifying a name"
+ assert err == None, "ERROR : command [deleteConfiguration] - Error while deleting configuration"
+ log.I("error correctly detected, no configuration deleted")
+ log.I("deleting a configuration on a wrong domain name")
+ out, err = self.pfw.sendCmd("deleteConfiguration","wrong_domain_name",new_conf_name)
+ assert out != "Done", "ERROR : command [deleteConfiguration] - Error not detected while deleting a configuration on a wrong domain name"
+ assert err == None, "ERROR : command [deleteConfiguration] - Error while deleting configuration"
+ log.I("error correctly detected, no configuration deleted")
+
+ # New domain configurations listing
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations = open("f_configurations", "w")
+ f_configurations.write(out)
+ f_configurations.close()
+
+ # Checking configurations names integrity
+ log.I("Configurations listing conformity check")
+ f_configurations = open("f_configurations", "r")
+ f_configurations_backup = open("f_configurations_backup", "r")
+ for iteration in range(self.new_conf_number):
+ listed_conf_backup = f_configurations_backup.readline().strip('\n')
+ listed_conf = f_configurations.readline().strip('\n')
+ assert listed_conf==listed_conf_backup, "ERROR : Error while listing configuration %s (found %s)" % (listed_conf_backup, listed_conf)
+ log.I("No change detected, listed configurations names conform to expected values")
+
+ # Testing domain deletion
+ log.I("End of test, new domain deletion")
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [deleteDomain] - Error while deleting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+
+ # Closing and deleting temp files
+ f_configurations_backup.close()
+ os.remove("f_configurations_backup")
+ f_configurations.close()
+ os.remove("f_configurations")
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal cases
+ ---------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Create new configurations
+ - List domain configurations
+ - Rename configurations
+ - Delete configurations
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listConfigurations] function
+ - [createConfiguration] function
+ - [renameConfiguration] function
+ - [deleteConfiguration] function
+ - [createDomain] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+ # New domain creation
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation
+ for iteration in range (self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ log.I("New configuration %s creation for domain %s" % (new_conf_name,self.domain_name))
+ log.I("command [createConfiguration]" )
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,new_conf_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (new_conf_name)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (new_conf_name,self.domain_name))
+
+ # Listing domain configurations
+ log.I("Configurations listing for domain %s" % (self.domain_name))
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations = open("f_configurations", "w")
+ f_configurations.write(out)
+ f_configurations.close()
+ # Checking configurations names integrity
+ log.I("Configurations listing conformity check")
+ f_configurations = open("f_configurations", "r")
+ for iteration in range(self.new_conf_number):
+ new_conf_name = "".join([self.conf_test, "_", str(iteration)])
+ listed_conf = f_configurations.readline().strip('\n')
+ assert listed_conf==new_conf_name, "ERROR : Error while listing configuration %s (found %s)" % (listed_conf, new_conf_name)
+ log.I("Listed configurations names conform to expected values")
+
+ # Configuration renaming
+ log.I("Configurations renaming")
+ for iteration in range (self.new_conf_number):
+ conf_name = "".join([self.conf_test, "_", str(iteration)])
+ new_conf_name = "".join([self.conf_test_renamed, "_", str(iteration)])
+ log.I("Configuration %s renamed to %s in domain %s" % (conf_name,new_conf_name,self.domain_name))
+ log.I("command [renameConfiguration]")
+ out, err = self.pfw.sendCmd("renameConfiguration",self.domain_name,conf_name,new_conf_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [renameConfiguration] - Error while renaming configuration %s to %s" % (conf_name,new_conf_name)
+ log.I("command [renameConfiguration] correctly executed")
+ log.I("Configuration %s renamed to %s for domain %s" % (conf_name,new_conf_name,self.domain_name))
+ # Listing domain configurations
+ log.I("Configurations listing to check configurations renaming")
+ log.I("command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name, "")
+ assert err == None, "ERROR : command [listConfigurations] - Error while listing configurations for domain %s" % (self.domain_name)
+ log.I("command [listConfigurations] correctly executed")
+ # Saving configurations names
+ f_configurations_renamed = open("f_configurations_renamed", "w")
+ f_configurations_renamed.write(out)
+ f_configurations_renamed.close()
+ # Checking configurations names integrity
+ log.I("Configurations listing conformity check")
+ f_configurations_renamed = open("f_configurations_renamed", "r")
+ for iteration in range(self.new_conf_number):
+ new_conf_name = "".join([self.conf_test_renamed, "_", str(iteration)])
+ listed_conf = f_configurations_renamed.readline().strip('\n')
+ assert listed_conf==new_conf_name, "ERROR : Error while renaming configuration %s (found %s)" % (new_conf_name,listed_conf)
+ log.I("Listed configurations names conform to expected values, renaming successfull")
+
+ # New domain deletion
+ log.I("End of test, new domain deletion")
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [deleteDomain] - Error while deleting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+
+ # Closing and deleting temp file
+ f_configurations.close()
+ os.remove("f_configurations")
+ f_configurations_renamed.close()
+ os.remove("f_configurations_renamed")
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Backup.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Backup.py
new file mode 100644
index 0000000..51d3d2b
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Backup.py
@@ -0,0 +1,239 @@
+# -*-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.
+
+"""
+Save and restore configuration testcases
+
+List of tested functions :
+--------------------------
+ - [saveConfiguration] function
+ - [restoreConfiguration] function
+
+Test cases :
+------------
+ - Testing nominal case
+ - Testing saveConfiguration errors
+ - Testing restoreConfiguration errors
+"""
+
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of Domains - save/restore configuration
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "Domain_0"
+ self.conf_1 = "Conf_0"
+ self.conf_2 = "Conf_1"
+ self.param_name = "/Test/Test/TEST_DIR/INT8"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal case
+ --------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - save a configuration
+ - restore a configuration
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [saveConfiguration] function
+ - [restoreConfiguration] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+
+ # Saving original parameter value
+ log.I("restoring configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "Error when restoring configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_1 = int(out)
+ log.I("saved parameter %s value on %s from domain %s = %s" % (self.param_name, self.conf_1, self.domain_name, Param_saved_1))
+
+ # Modifying parameter value
+ log.I("modifying parameter %s value on configuration %s from domain %s" % (self.param_name, self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, str(Param_saved_1+1))
+ assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
+ log.I("new parameter %s value = %s in place of %s" % (self.param_name, str(Param_saved_1+1), Param_saved_1))
+
+ # Saving new parameter value
+ log.I("saving configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("saveConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "Error when saving configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_1 = int(out)
+ log.I("new saved parameter %s value on %s from domain %s = %s" % (self.param_name, self.conf_1, self.domain_name, Param_saved_1))
+
+ # Modifying and restoring parameter value
+ log.I("modifying parameter %s value on configuration %s from domain %s" % (self.param_name, self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, str(Param_saved_1+1))
+ assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_2 = int(out)
+ log.I("new parameter %s value on %s = %s in place of %s" % (self.param_name, self.conf_1, str(Param_saved_2), Param_saved_1))
+ log.I("restoring configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "Error when restoring configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_2 = int(out)
+ assert Param_saved_2 == Param_saved_1, "Error when restoring configuration %s from domain %s" % (self.conf_1, self.domain_name)
+ log.I("saving and restoring configuration works fine")
+
+ def test_Save_Config_Error(self):
+ """
+ Testing saveConfiguration error
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - save a configuration with a missing argument
+ - save a configuration with a wrong domain name
+ - save a configuration with a wrong configuration name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [saveConfiguration] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - errors correctly detected
+ """
+ log.D(self.test_Save_Config_Error.__doc__)
+ # Saving original parameter value and setting a new value to parameter for testing purpose
+ log.I("restoring configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "Error when restoring configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_1 = int(out)
+ log.I("saved parameter %s value on %s from domain %s = %s" % (self.param_name, self.conf_1, self.domain_name, Param_saved_1))
+ log.I("modifying parameter %s value on configuration %s from domain %s" % (self.param_name, self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, str(Param_saved_1+1))
+ assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
+ log.I("new parameter %s value = %s in place of %s" % (self.param_name, str(Param_saved_1+1), Param_saved_1))
+
+ # Configuration saving errors
+ log.I("saving configuration error test cases :")
+ log.I("saving configuration with a missing argument")
+ out, err = self.pfw.sendCmd("saveConfiguration", self.domain_name)
+ assert err == None, "ERROR : Error when saving configuration with a missing argument"
+ assert out != "Done", "ERROR : Error not detected when saving configuration with a missing argument"
+ log.I("saving configuration with a wrong domain name")
+ out, err = self.pfw.sendCmd("saveConfiguration", "Wrong_Domain_Name", self.conf_1)
+ assert err == None, "ERROR : Error when saving configuration with a wrong domain name"
+ assert out != "Done", "ERROR : Error not detected when saving configuration with a wrong domain name"
+ log.I("saving configuration with a wrong configuration name")
+ out, err = self.pfw.sendCmd("saveConfiguration", self.domain_name, "Wrong_Configuration_Name")
+ assert err == None, "ERROR : Error when saving configuration with a wrong configuration name"
+ assert out != "Done", "ERROR : Error not detected when saving configuration with a wrong configuration name"
+ log.I("saving configuration error test cases : errors correctly detected")
+
+ # Checking that no error has affected original configuration save
+ log.I("restoring configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "error when restoring configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_2 = int(out)
+ assert Param_saved_2 == Param_saved_1, "error when restoring configuration %s from domain %s, parameter %s affected by configuration saving error" % (self.conf_1, self.domain_name, Param_saved_1)
+ log.I("Test passed : saving errors correctly detected, no impact on previously saved configuration")
+
+ def test_Restore_Config_Error(self):
+ """
+ Testing restoreConfiguration error
+ ----------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - restore a configuration with a missing argument
+ - restore a configuration with a wrong domain name
+ - restore a configuration with a wrong configuration name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - errors correctly detected
+ - configuration's parameters not affected by errors
+ """
+
+ log.D(self.test_Restore_Config_Error.__doc__)
+ # Saving original parameter value and setting a new value to parameter for testing purpose
+ log.I("restore configuration %s from domain %s" % (self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, self.conf_1)
+ assert err == None, "Error when restoring configuration %s from domain %s : %s" % (self.conf_1, self.domain_name, err)
+ assert out == "Done", out
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_1 = int(out)
+ log.I("saved parameter %s value on %s from domain %s = %s" % (self.param_name, self.conf_1, self.domain_name, Param_saved_1))
+ log.I("modifying parameter %s value on configuration %s from domain %s" % (self.param_name, self.conf_1, self.domain_name))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, str(Param_saved_1+1))
+ assert err == None, "Error when setting parameter %s : %s" % (self.param_name, err)
+ log.I("new parameter %s value = %s in place of %s" % (self.param_name, str(Param_saved_1+1), Param_saved_1))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "Error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_2 = int(out)
+
+ # Configuration restore errors
+ log.I("restoring configuration error test cases :")
+ log.I("restoring configuration with a missing argument")
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name)
+ assert err == None, "ERROR : Error when restoring configuration with a missing argument"
+ assert out != "Done", "ERROR : Error not detected when restoring configuration with a missing argument"
+ log.I("restoring configuration with a wrong domain name")
+ out, err = self.pfw.sendCmd("restoreConfiguration", "Wrong_Domain_Name", self.conf_1)
+ assert err == None, "ERROR : Error when restoring configuration with a wrong domain name"
+ assert out != "Done", "ERROR : Error not detected when restoring configuration with a wrong domain name"
+ log.I("restoring configuration with a wrong configuration name")
+ out, err = self.pfw.sendCmd("restoreConfiguration", self.domain_name, "Wrong_Configuration_Name")
+ assert err == None, "ERROR : Error when restoring configuration with a wrong configuration name"
+ assert out != "Done", "ERROR : Error not detected when restoring configuration with a wrong configuration name"
+ log.I("restoring configuration error test cases : errors correctly detected")
+
+ # Checking that no error has affected configuration's parameter value
+ out, err = self.pfw.sendCmd("getParameter", self.param_name)
+ assert err == None, "error when getting parameter %s : %s" % (self.param_name, err)
+ Param_saved_1 = int(out)
+ assert Param_saved_2 == Param_saved_1, "error when restoring configuration %s from domain %s, parameter %s affected by configuration restoration error" % (self.conf_1, self.domain_name, Param_saved_1)
+ log.I("Test passed : restoring errors correctly detected, no impact on previously modified configuration's parameter")
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Selection.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Selection.py
new file mode 100644
index 0000000..f67ab5f
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Configuration_Selection.py
@@ -0,0 +1,185 @@
+# -*-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.
+
+"""
+Effect of criteria changes on configuration testcases
+
+List of tested functions :
+--------------------------
+ - [applyConfigurations] function
+ - [setCriterionState] function
+
+Test cases :
+------------
+ - test_Combinatorial_Criteria
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.reference_xml = "$PFW_TEST_TOOLS/xml/XML_Test/Reference_Criteria.xml"
+ self.temp_domain="f_Domains_Backup"
+ self.temp_status="f_Config_Status"
+ # Expected results are defined by Reference_Criteria.xml configuration settings
+ self.expected_result = [["Conf_1_1", "<none>", "Conf_3_0"] ,
+ ["Conf_1_1", "Conf_2_1", "Conf_3_1"] ,
+ ["Conf_1_1", "Conf_2_1", "Conf_3_0"] ,
+ ["Conf_1_1", "Conf_2_0", "Conf_3_0"] ,
+ ["Conf_1_0", "Conf_2_0", "Conf_3_0"] ,
+ ["Conf_1_1", "Conf_2_0", "Conf_3_0"] ,
+ ["Conf_1_1", "Conf_2_0", "Conf_3_1"]]
+ self.criterion_setup = [["0x2", "1"] ,
+ ["0x2", "0"] ,
+ ["0x1", "0"] ,
+ ["0x1", "1"] ,
+ ["0x3", "4"] ,
+ ["0x0", "1"]]
+ # names used in this test refer to names used in Reference_Criteria.xml
+ self.new_domain_name = "Domain"
+ self.crit_change_iteration = 6
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Combinatorial_Criteria(self):
+ """
+ Testing combinatorial criteria
+ ------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ Checking that PFW behaviour is in line with expectations when setting criteria states.
+ - Test of all combinatorial of criteria and possible errors
+ - nominal case in configuration selection
+ - conflict in configuration selection
+ - no configuration selected
+ - error in criterion setting
+ - test of compound rules : All / Any
+ - test of matches cases : Is / IsNot / Include / Exclude
+ - test of criteria types : Inclusive / Exclusive
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [applyConfigurations] function
+ - [setCriterionState] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Configurations setting conform to expected behavior
+ """
+ log.D(self.test_Combinatorial_Criteria.__doc__)
+
+ # Import a reference XML file
+ log.I("Import Domains with settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ # Check number of domain
+ log.I("Current domains listing")
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ log.I("Command [listDomains] : correctly executed")
+
+ # Domains listing backup
+ f_Domains_Backup = open(self.temp_domain, "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open(self.temp_domain, "r")
+ domains_nbr = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr+=1
+ f_Domains_Backup.close()
+
+ # Applying default configurations
+ out, err = self.pfw.sendCmd("setTuningMode", "off")
+ assert err == None, log.E("Command [setTuningMode]")
+ out, err = self.hal.sendCmd("applyConfigurations")
+ assert err == None, log.E("Command HAL [applyConfigurations]")
+
+ # Saving default status
+ out, err = self.pfw.sendCmd("status")
+ f_Config_Status = open(self.temp_status, "w")
+ f_Config_Status.write(out)
+ f_Config_Status.close()
+
+ # Test cases iterations
+ for iteration in range (self.crit_change_iteration+1):
+
+ # Criteria settings
+ # No criteria are set at the first iteration for testing default configurations
+ if iteration != 0:
+ log.I("Setting criterion %s to %s" % ("Crit_0", str(self.criterion_setup[iteration-1][0])))
+ state = str(self.criterion_setup[iteration-1][0])
+ out, err = self.hal.sendCmd("setCriterionState", "Crit_0", state)
+ assert err == None, log.E("Command HAL [setCriterionState]")
+ log.I("Setting criterion %s to %s" % ("Crit_1", str(self.criterion_setup[iteration-1][1])))
+ state = str(self.criterion_setup[iteration-1][1])
+ out, err = self.hal.sendCmd("setCriterionState", "Crit_1", state)
+ assert err == None, log.E("Command HAL [setCriterionState]")
+ log.I("Applaying new configurations")
+ out, err = self.hal.sendCmd("applyConfigurations")
+ assert err == None, log.E("Command HAL [applyConfigurations]")
+ out, err = self.pfw.sendCmd("status")
+ assert err == None, log.E("Command [status]")
+ os.remove(self.temp_status)
+ f_Config_Status = open(self.temp_status, "w")
+ f_Config_Status.write(out)
+ f_Config_Status.close()
+ else :
+ log.I("Default Configurations - no criteria are set :")
+ out, err = self.pfw.sendCmd("status")
+ os.remove(self.temp_status)
+ f_Config_Status = open(self.temp_status, "w")
+ f_Config_Status.write(out)
+ f_Config_Status.close()
+
+ # Configurations checking
+ for domain in range (domains_nbr):
+ domain_name = "".join([self.new_domain_name, "_", str(domain+1)])
+ config = str(self.expected_result[iteration][domain])
+ log.I("Checking that domain %s is set to configuration : %s" % (domain_name,config))
+ for line in open(self.temp_status, "r"):
+ if domain_name in line:
+ line = line.replace(domain_name,'')
+ line = line.replace(":","")
+ line = line.replace(' ','')
+ line = line.replace("\n","")
+ assert line == config, log.F("Domain %s - Expected configuration : %s, found : %s" % (domain_name,config,line))
+ log.I("Domain %s - configuration correctly set to %s" % (domain_name,line))
+
+ # Temporary files deletion
+ os.remove(self.temp_domain)
+ os.remove(self.temp_status)
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Elements.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Elements.py
new file mode 100644
index 0000000..8651968
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Elements.py
@@ -0,0 +1,311 @@
+# -*-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.
+
+"""
+Adding and Removing elements from domain testcases
+
+List of tested functions :
+--------------------------
+ - [listDomainElements] function
+ - [addElement] function
+ - [removeElement] function
+
+Test cases :
+------------
+ - Testing nominal case
+ - Testing addElement errors
+ - Testing removeElement errors
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "Domain_0"
+ self.elem_0_path = "/Test/Test/TEST_DIR"
+ self.elem_1_path = "/Test/Test/TEST_DOMAIN_0"
+ self.elem_2_path = "/Test/Test/TEST_DOMAIN_1"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal case
+ --------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - list and backup initial domain elements
+ - add a domain element
+ - remove a domain element
+ - list and check domains elements
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listDomainElements] function
+ - [addElement] function
+ - [removeElement] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+
+ # List and backup initial domain elements
+ log.I("Listing initial domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "w")
+ f_DomainElements_Backup.write(out)
+ f_DomainElements_Backup.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ element_nbr_init = 0
+ line=f_DomainElements_Backup.readline()
+ while line!="":
+ line=f_DomainElements_Backup.readline()
+ element_nbr_init+=1
+ f_DomainElements_Backup.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr_init))
+
+ # Adding a new domain element
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ log.I("New domain elements %s and %s added to domain %s" % (self.elem_1_path, self.elem_2_path, self.domain_name))
+
+ # Removing a domain element
+ log.I("Removing domain element %s from domain %s" % (self.elem_1_path,self.domain_name))
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+
+ # Checking final domain elements
+ log.I("Listing final domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements = open("f_DomainElements", "w")
+ f_DomainElements.write(out)
+ f_DomainElements.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements = open("f_DomainElements", "r")
+ element_nbr = 0
+ line=f_DomainElements.readline()
+ while line!="":
+ line=f_DomainElements.readline()
+ element_nbr+=1
+ f_DomainElements.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr))
+ log.I("Checking domain %s elements names conformity" % (self.domain_name))
+ f_DomainElements = open("f_DomainElements", "r")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ for line in range(element_nbr):
+ # initial domain elements shall not have been impacted by current test
+ if (line < element_nbr_init):
+ element_name = f_DomainElements.readline().strip('\n')
+ element_name_backup = f_DomainElements_Backup.readline().strip('\n')
+ assert element_name==element_name_backup, "ERROR : Error while modifying domain elements on domain %s" % (self.domain_name)
+ # last listed element shall be equal to the only one element added previously
+ else:
+ element_name = f_DomainElements.readline().strip('\n')
+ assert element_name==str(self.elem_2_path), "ERROR : Error while modifying domain elements on domain %s" % (self.domain_name)
+ log.I("Actual domain %s elements names conform to expected values" % (self.domain_name))
+ # Temporary files deletion
+ f_DomainElements.close()
+ f_DomainElements_Backup.close()
+ os.remove("f_DomainElements_Backup")
+ os.remove("f_DomainElements")
+ # Removing created domain element
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
+
+ def test_addElement_Error(self):
+ """
+ Testing addElement error
+ ------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - add an already existing domain element
+ - add a non defined domain element
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [addElement] function
+ - [listDomainElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Errors correctly detected
+ - No side effect
+ """
+ log.D(self.test_addElement_Error.__doc__)
+
+ # List and backup initial domain elements
+ log.I("Listing initial domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "w")
+ f_DomainElements_Backup.write(out)
+ f_DomainElements_Backup.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ element_nbr_init = 0
+ line=f_DomainElements_Backup.readline()
+ while line!="":
+ line=f_DomainElements_Backup.readline()
+ element_nbr_init+=1
+ f_DomainElements_Backup.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr_init))
+
+ # Adding a new domain element errors
+ log.I("Adding an already existing domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_0_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_0_path)
+ assert out != "Done", "ERROR : command [addElement] - Error not detected while adding an already existing domain element to domain %s" % (self.domain_name)
+ log.I("Adding a non defined domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), "Non_Defined_Element")
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ assert out != "Done", "ERROR : command [addElement] - Error not detected while adding a non defined domain element to domain %s" % (self.domain_name)
+ log.I("Error when adding elements correctly detected")
+
+ # Checking final domain elements
+ log.I("Listing final domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements = open("f_DomainElements", "w")
+ f_DomainElements.write(out)
+ f_DomainElements.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements = open("f_DomainElements", "r")
+ element_nbr = 0
+ line=f_DomainElements.readline()
+ while line!="":
+ line=f_DomainElements.readline()
+ element_nbr+=1
+ f_DomainElements.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr))
+ log.I("Checking domain %s elements names conformity" % (self.domain_name))
+ f_DomainElements = open("f_DomainElements", "r")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ for line in range(element_nbr):
+ # initial domain elements shall not have been impacted by current test
+ element_name = f_DomainElements.readline().strip('\n')
+ element_name_backup = f_DomainElements_Backup.readline().strip('\n')
+ assert element_name==element_name_backup, "ERROR : domain %s elements affected by addElement errors" % (self.domain_name)
+ log.I("Actual domain %s elements names conform to expected values" % (self.domain_name))
+ # Temporary files deletion
+ f_DomainElements.close()
+ f_DomainElements_Backup.close()
+ os.remove("f_DomainElements_Backup")
+ os.remove("f_DomainElements")
+
+ def test_removeElement_Error(self):
+ """
+ Testing removeElement error
+ ---------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - remove a non defined domain element
+ - remove a domain element on a wrong domain name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [removeElement] function
+ - [listDomainElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Errors correctly detected
+ - No side effect
+ """
+ log.D(self.test_removeElement_Error.__doc__)
+
+ # List and backup initial domain elements
+ log.I("Listing initial domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "w")
+ f_DomainElements_Backup.write(out)
+ f_DomainElements_Backup.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ element_nbr_init = 0
+ line=f_DomainElements_Backup.readline()
+ while line!="":
+ line=f_DomainElements_Backup.readline()
+ element_nbr_init+=1
+ f_DomainElements_Backup.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr_init))
+
+ # Error when removing domain elements
+ log.I("Removing a domain element from a non defined domain")
+ out, err = self.pfw.sendCmd("removeElement", "Wrong_Domain_Name", str(self.elem_0_path))
+ assert err == None, "ERROR : command [removeElement] - Error when removing domain element %s" % (self.elem_0_path)
+ assert out != "Done", "ERROR : command [removeElement] - Error not detected when removing domain element %s from an undefined domain"% (self.elem_0_path)
+ log.I("Removing a non existent domain element from domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), "Wrong_Element_Name")
+ assert err == None, "ERROR : command [removeElement] - Error when removing domain element %s" % (self.elem_0_path)
+ assert out != "Done", "ERROR : command [removeElement] - Error not detected when removing a non existent domain element from domain %s" % (self.domain_name)
+ log.I("Error when removing elements correctly detected")
+
+ # Checking final domain elements
+ log.I("Listing final domain %s elements" % (self.domain_name))
+ out, err = self.pfw.sendCmd("listDomainElements",str(self.domain_name))
+ assert err == None, "ERROR : command [listDomainElements] - Error while listing domain elements"
+ f_DomainElements = open("f_DomainElements", "w")
+ f_DomainElements.write(out)
+ f_DomainElements.close()
+ log.I("command [listDomainElements] correctly executed")
+ f_DomainElements = open("f_DomainElements", "r")
+ element_nbr = 0
+ line=f_DomainElements.readline()
+ while line!="":
+ line=f_DomainElements.readline()
+ element_nbr+=1
+ f_DomainElements.close()
+ log.I("Actual domain %s elements number is %s" % (self.domain_name,element_nbr))
+ log.I("Checking domain %s elements names conformity" % (self.domain_name))
+ f_DomainElements = open("f_DomainElements", "r")
+ f_DomainElements_Backup = open("f_DomainElements_Backup", "r")
+ for line in range(element_nbr):
+ # initial domain elements shall not have been impacted by current test
+ element_name = f_DomainElements.readline().strip('\n')
+ element_name_backup = f_DomainElements_Backup.readline().strip('\n')
+ assert element_name==element_name_backup, "ERROR : domain %s elements affected by addElement errors" % (self.domain_name)
+ log.I("Actual domain %s elements names conform to expected values" % (self.domain_name))
+ # Temporary files deletion
+ f_DomainElements.close()
+ f_DomainElements_Backup.close()
+ os.remove("f_DomainElements_Backup")
+ os.remove("f_DomainElements")
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Elements_Sequences.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Elements_Sequences.py
new file mode 100644
index 0000000..1544cae
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Elements_Sequences.py
@@ -0,0 +1,294 @@
+# -*-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.
+
+"""
+Element Sequence testcases
+
+List of tested functions :
+--------------------------
+ - [setElementSequence] function
+ - [getElementSequence] function
+
+Test cases :
+------------
+ - Testing setElementSequence errors
+ - Testing getElementSequence errors
+ - Testing nominal case
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "Domain_0"
+ self.elem_0_path = "/Test/Test/TEST_DIR"
+ self.elem_1_path = "/Test/Test/TEST_DOMAIN_0"
+ self.elem_2_path = "/Test/Test/TEST_DOMAIN_1"
+ self.configuration = "Conf_0"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal case
+ --------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - set a new sequences order for a selected configuration
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setElementSequence] function
+ - [getElementSequence] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ - new sequences order conform to expected order
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+
+ # Adding new domain elements
+ log.I("Working on domain %s" % (self.domain_name))
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ log.I("New domain elements %s and %s added to domain %s" % (self.elem_1_path, self.elem_2_path, self.domain_name))
+
+ # Getting elements sequence from selected configuration
+ log.I("Getting elements sequence from configuration %s" % (self.configuration))
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ log.I("Listing elements sequence for configuration %s correctly executed :\n%s" % (self.configuration, out))
+
+ # Setting new elements sequence order for selected configuration
+ log.I("Setting new elements sequence order for configuration %s" % (self.configuration))
+ out, err = self.pfw.sendCmd("setElementSequence", self.domain_name, self.configuration, self.elem_2_path, self.elem_0_path, self.elem_1_path)
+ assert err == None, "ERROR : command [setElementSequence] - Error while setting new elements sequence for configuration %s" % (self.configuration)
+ assert out == "Done", "ERROR : command [setElementSequence] - Error while setting new elements sequence for configuration %s" % (self.configuration)
+ log.I("Setting new elements sequence for configuration %s correctly executed")
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ log.I("New elements sequence for configuration %s :\n%s" % (self.configuration, out))
+
+ # Checking new elements sequence order conformity for selected configuration
+ log.I("Checking new elements sequence order for configuration")
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "w")
+ f_ConfigElementsOrder.write(out)
+ f_ConfigElementsOrder.close()
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "r")
+ element_name = f_ConfigElementsOrder.readline().strip('\n')
+ assert element_name==self.elem_2_path, "ERROR : Error while modifying configuration %s elements order on domain %s" % (self.configuration)
+ element_name = f_ConfigElementsOrder.readline().strip('\n')
+ assert element_name==self.elem_0_path, "ERROR : Error while modifying configuration %s elements order on domain %s" % (self.configuration)
+ element_name = f_ConfigElementsOrder.readline().strip('\n')
+ assert element_name==self.elem_1_path, "ERROR : Error while modifying configuration %s elements order on domain %s" % (self.configuration)
+ log.I("New elements sequence order conform to expected order for configuration %s" % (self.configuration))
+ # Closing and removing temp file
+ f_ConfigElementsOrder.close()
+ os.remove("f_ConfigElementsOrder")
+ # Removing created domain element
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
+
+ def test_setElementSequence_errors(self):
+ """
+ Testing setElementSequence_errors
+ ---------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Setting an element not belonging to configuration
+ - Setting undefined element in sequence order
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setElementSequence] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors correctly detected
+ - no impact on initial sequences order
+ """
+ log.D(self.test_setElementSequence_errors.__doc__)
+
+ # Adding a new domain element
+ log.I("Working on domain %s" % (self.domain_name))
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ log.I("New domain element %s added to domain %s" % (self.elem_1_path, self.domain_name))
+
+ # Getting elements sequence from selected configuration
+ log.I("Getting elements sequence from configuration %s" % (self.configuration))
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ log.I("Listing elements sequence for configuration %s correctly executed :\n%s" % (self.configuration, out))
+
+ # Elements sequence backup
+ f_ConfigElementsOrder_Backup = open("f_ConfigElementsOrder_Backup", "w")
+ f_ConfigElementsOrder_Backup.write(out)
+ f_ConfigElementsOrder_Backup.close()
+
+ # Setting an element not belonging to configuration in sequence order
+ log.I("Setting an element not belonging to configuration %s in sequence order" % (self.configuration))
+ out, err = self.pfw.sendCmd("setElementSequence", self.domain_name, self.configuration, self.elem_2_path, self.elem_0_path, self.elem_1_path)
+ assert err == None, "ERROR : command [setElementSequence] - Error while setting elements sequence for configuration %s" % (self.configuration)
+ assert out != "Done", "ERROR : command [setElementSequence] - Error not detected when setting an element not belonging to configuration"
+
+ # Setting undefined element in sequence order for selected configuration
+ log.I("Setting undefined element in sequence order for configuration %s" % (self.configuration))
+ out, err = self.pfw.sendCmd("setElementSequence", self.domain_name, self.configuration, "Wrong_Element_Name", self.elem_0_path, self.elem_1_path)
+ assert err == None, "ERROR : command [setElementSequence] - Error while setting elements sequence for configuration %s" % (self.configuration)
+ assert out != "Done", "ERROR : command [getElementSequence] - Error not detected when setting an undefined element to configuration"
+
+ # Getting elements sequence from selected configuration for checking purpose
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ # Elements sequence backup
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "w")
+ f_ConfigElementsOrder.write(out)
+ f_ConfigElementsOrder.close()
+
+ # Checking new elements sequence order conformity for selected configuration
+ log.I("Checking new elements sequence order for configuration")
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "r")
+ f_ConfigElementsOrder_Backup = open("f_ConfigElementsOrder_Backup", "r")
+ new_element_name = f_ConfigElementsOrder.readline().strip('\n')
+ element_name = f_ConfigElementsOrder_Backup.readline().strip('\n')
+ assert element_name==new_element_name, "ERROR : setElementSequence errors have affected elements order on domain %s" % (self.configuration)
+ new_element_name = f_ConfigElementsOrder.readline().strip('\n')
+ element_name = f_ConfigElementsOrder_Backup.readline().strip('\n')
+ assert element_name==new_element_name, "ERROR : setElementSequence errors have affected elements order on domain %s" % (self.configuration)
+ log.I("Elements sequence order not affected by setElementSequence errors")
+
+ # Closing and removing temp file
+ f_ConfigElementsOrder.close()
+ f_ConfigElementsOrder_Backup.close()
+ os.remove("f_ConfigElementsOrder")
+ os.remove("f_ConfigElementsOrder_Backup")
+ # Removing created domain element
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+
+ def test_getElementSequence_errors(self):
+ """
+ Testing getElementSequence_errors
+ ---------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Getting an element sequence on a wrong domain name
+ - Getting an element sequence on a wrong configuration name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [getElementSequence] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors correctly detected
+ - no impact on initial sequences order
+ """
+ log.D(self.test_getElementSequence_errors.__doc__)
+
+ # Adding new domain elements
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_1_path)
+ log.I("Adding a new domain element to domain %s" % (self.domain_name))
+ out, err = self.pfw.sendCmd("addElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [addElement] - Error while adding new domain element %s" % (self.elem_2_path)
+ log.I("New domain elements %s and %s added to domain %s" % (self.elem_1_path, self.elem_2_path, self.domain_name))
+
+ # Getting elements sequence from selected configuration
+ log.I("Getting elements sequence from configuration %s" % (self.configuration))
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ log.I("Listing elements sequence for configuration %s correctly executed :\n%s" % (self.configuration, out))
+
+ # Elements sequence backup
+ f_ConfigElementsOrder_Backup = open("f_ConfigElementsOrder_Backup", "w")
+ f_ConfigElementsOrder_Backup.write(out)
+ f_ConfigElementsOrder_Backup.close()
+
+ # Getting an element sequence on a wrong domain name
+ log.I("Getting an element sequence on a wrong domain name")
+ out, err = self.pfw.sendCmd("getElementSequence", "Wrong_Domain_Name", self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error when getting elements sequence for configuration %s" % (self.configuration)
+ assert out != "Done", "ERROR : command [getElementSequence] - Error not detected when getting elements sequence for a wrong domain name"
+
+ # Getting an element sequence on a wrong configuration name
+ log.I("Getting an element sequence on a wrong configuration name")
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, "Wrong_Configuration_Name")
+ assert err == None, "ERROR : command [getElementSequence] - Error when getting elements sequence on a wrong configuration name"
+ assert out != "Done", "ERROR : command [getElementSequence] - Error not detected when getting elements sequence on a wrong configuration name"
+
+ # Getting elements sequence from selected configuration for checking purpose
+ out, err = self.pfw.sendCmd("getElementSequence", self.domain_name, self.configuration)
+ assert err == None, "ERROR : command [getElementSequence] - Error while listing elements sequence for configuration %s" % (self.configuration)
+ # Elements sequence backup
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "w")
+ f_ConfigElementsOrder.write(out)
+ f_ConfigElementsOrder.close()
+
+ # Checking new elements sequence order conformity for selected configuration
+ log.I("Checking new elements sequence order for configuration")
+ f_ConfigElementsOrder = open("f_ConfigElementsOrder", "r")
+ f_ConfigElementsOrder_Backup = open("f_ConfigElementsOrder_Backup", "r")
+ new_element_name = f_ConfigElementsOrder.readline().strip('\n')
+ element_name = f_ConfigElementsOrder_Backup.readline().strip('\n')
+ assert element_name==new_element_name, "ERROR : getElementSequence errors have affected elements order on domain %s" % (self.configuration)
+ new_element_name = f_ConfigElementsOrder.readline().strip('\n')
+ element_name = f_ConfigElementsOrder_Backup.readline().strip('\n')
+ assert element_name==new_element_name, "ERROR : getElementSequence errors have affected elements order on domain %s" % (self.configuration)
+ log.I("Elements sequence order not affected by getElementSequence errors")
+
+ # Closing and removing temp file
+ f_ConfigElementsOrder.close()
+ f_ConfigElementsOrder_Backup.close()
+ os.remove("f_ConfigElementsOrder")
+ os.remove("f_ConfigElementsOrder_Backup")
+ # Removing created domain element
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_1_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_1_path)
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_name), str(self.elem_2_path))
+ assert err == None, "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
+ assert out == "Done", "ERROR : command [removeElement] - Error while removing domain element %s" % (self.elem_2_path)
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Rules.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Rules.py
new file mode 100644
index 0000000..0084e22
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Rules.py
@@ -0,0 +1,443 @@
+# -*-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.
+
+"""
+Rules management testcases
+
+List of tested functions :
+--------------------------
+ - [setRule] function
+ - [clearRule] function
+ - [getRule] function
+
+Test cases :
+------------
+ - Testing clearRule errors
+ - Testing setRule errors
+ - Testing getRule errors
+ - Testing nominal case
+"""
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of Domains - Rules
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "domain_test"
+ self.conf_1 = "conf_1"
+ self.conf_2 = "conf_2"
+ self.rule_1 = "Any{Crit_0 Includes State_0x2, Crit_1 IsNot State_1}"
+ self.rule_2 = "All{Crit_0 Includes State_0x1, Crit_1 Is State_1}"
+ self.rule_error_1 = "All{Crit_Error Includes State_0x1, Crit_1 Is State_1}"
+ self.rule_error_2 = "Any{Crit_0 Includes State_0x2, Crit_0 IsNot State_1}"
+ self.rule_error_3 = "Ay{Crit_0 Includes State_0x2, Crit_1 IsNot State_1}"
+ self.rule_error_4 = "All{Crit_0 Includes State_0x4, Crit_1 IsNot State_1}"
+ self.rule_error_5 = "All{Crit_0 Includes State_0x2, Crit_1 IsNot 1}"
+ self.rule_error_nbr = 5
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_ClearRule_Errors(self):
+ """
+ Testing configuration creation error
+ ------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Clearing rule on a non-existent configuration
+ - Clearing rule on a non-existent domain
+ - Clearing rule with wrong parameters order
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [clearRule] function
+ - [setRule] function
+ - [getRule] function
+ - [createDomain] function
+ - [createConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected
+ - no rule is deleted
+ """
+ log.D(self.test_ClearRule_Errors.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
+
+ # Applying rules to configurations
+ log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_1))
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_2))
+
+ # Clearing rule errors
+ log.I("Clearing a rule on domain %s to a non-existent configuration" % (self.domain_name))
+ log.I("command [clearRule]")
+ out, err = self.pfw.sendCmd("clearRule",self.domain_name,"Wrong_Config_Name")
+ assert err == None, "ERROR : command [clearRule] - Error while clearing rule on domain %s to a non-existent configuration" % (self.domain_name)
+ assert out != "Done", "ERROR : command [clearRule] - Error not detected while clearing rule on domain %s to a non-existent configuration" % (self.domain_name)
+ log.I("error correctly detected when clearing a rule to a non-existent configuration")
+ log.I("Clearing a rule on a non-existent domain")
+ log.I("command [clearRule]")
+ out, err = self.pfw.sendCmd("clearRule","Wrong_Domain_Name",self.conf_2)
+ assert err == None, "ERROR : command [clearRule] - Error while clearing rule on a non-existent domain"
+ assert out != "Done", "ERROR : command [clearRule] - Error not detected while clearing rule on a non-existent domain"
+ log.I("error correctly detected while clearing rule on a non-existent domain")
+ log.I("Clearing a rule with wrong parameters order")
+ log.I("command [clearRule]")
+ out, err = self.pfw.sendCmd("clearRule",self.conf_1,self.domain_name)
+ assert err == None, "ERROR : command [clearRule] - Error when clearing a rule with incorrect paramaters order"
+ assert out != "Done", "ERROR : command [clearRule] - Error not detected when clearing a rule with incorrect paramaters order"
+ log.I("error correctly detected when clearing a rule with incorrect paramaters order on domain %s and configuration %s" % (self.domain_name,self.conf_1))
+
+ #Checking that no rule has been cleared
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
+ assert out == self.rule_1, "FAIL : command [clearRule] - clearRule error has affected configuration %s" % (self.conf_1)
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
+ assert out == self.rule_2, "FAIL : command [clearRule] - clearRule error has affected configuration %s" % (self.conf_2)
+ log.I("command [ClearRule] correctly executed, no impact due to clearing errors")
+ log.I("no rule removed from configurations %s and %s on domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+
+ # New domain deletion
+ log.I("Domain %s deletion" % (self.domain_name))
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+ log.I("Domain %s deleted" % (self.domain_name))
+
+ def test_SetRule_Errors(self):
+ """
+ Testing setRule errors
+ ----------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Setting rule on a non-existent configuration
+ - Setting rule on a non-existent domain
+ - Setting various incorrect format rules
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setRule] function
+ - [getRule] function
+ - [createDomain] function
+ - [createConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected
+ - no new rule is created
+ """
+ log.D(self.test_SetRule_Errors.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configuration creation for testing purpose
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
+
+ # setRule :basic error cases
+ log.I("Applying a new rule on domain %s to a non-existent configuration" % (self.domain_name))
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,"Wrong_Config_Name",self.rule_1)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule on domain %s to a non-existent configuration" % (self.domain_name)
+ assert out != "Done", "ERROR : command [setRule] - Error not detected while setting rule on domain %s to a non-existent configuration" % (self.domain_name)
+ log.I("error correctly detected when creating a rule to a non-existent configuration")
+ log.I("Applying a new rule on a non-existent domain")
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule","Wrong_Domain_Name",self.conf_1,self.rule_1)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule on a non-existent domain"
+ assert out != "Done", "ERROR : command [setRule] - Error not detected while setting rule on a non-existent domain"
+ log.I("error correctly detected while setting rule on a non-existent domain")
+ log.I("Applying a new rule with incorrect format")
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,"Wrong_Rule_Format")
+ assert err == None, "ERROR : command [setRule] - Error when setting incorrect format rule"
+ assert out != "Done", "ERROR : command [setRule] - Error not detected when setting incorrect format rule"
+ log.I("error correctly detected when setting incorrect format rule on domain %s and configuration %s" % (self.domain_name,self.conf_1))
+
+ # setRule : various rules errors
+ log.I("Various rules errors setting :")
+ for index in range (self.rule_error_nbr):
+ log.I("Rule error number %s" % (str(index)))
+ rule_name = "".join(["self.rule_error_", "_", str(index)])
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1, rule_name)
+ assert err == None, "ERROR : command [setRule] - Error when setting incorrect format rule %s" % (str(rule_name))
+ assert out != "Done", "ERROR : command [setRule] - Error not detected when setting incorrect format rule %s" % (str(rule_name))
+ log.I("error correctly detected when setting incorrect format rule on domain %s and configuration %s" % (self.domain_name,self.conf_1))
+
+ #Checking that no rule has been created
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
+ assert out == "<none>", "FAIL : command [setRule] - setRule not working for configuration %s" % (self.conf_1)
+ log.I("command [setRule] correctly executed, no impact due to setting errors")
+ log.I("no rule added to configurations %s on domain %s" % (self.conf_1,self.domain_name))
+
+ # New domain deletion
+ log.I("Domain %s deletion" % (self.domain_name))
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+ log.I("Domain %s deleted" % (self.domain_name))
+
+ def test_GetRule_Errors(self):
+ """
+ Testing getRule errors
+ ----------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Getting rule on a non-existent configuration
+ - Getting rule on a non-existent domain
+ - Getting rule with wrong parameters order
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [getRule] function
+ - [setRule] function
+ - [clearRule] function
+ - [createDomain] function
+ - [createConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected
+ """
+ log.D(self.test_GetRule_Errors.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
+
+ # Applying rules to configurations
+ log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_1))
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_2))
+
+ # Getting rule errors
+ log.I("Getting a rule on domain %s from a non-existent configuration" % (self.domain_name))
+ log.I("command [getRule]")
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,"Wrong_Config_Name")
+ assert err == None, "ERROR : command [getRule] - Error when getting rule on domain %s from a non-existent configuration" % (self.domain_name)
+ assert out != "Done", "ERROR : command [getRule] - Error not detected while getting rule on domain %s from a non-existent configuration" % (self.domain_name)
+ log.I("error correctly detected when getting a rule from a non-existent configuration")
+ log.I("getting a rule from a non-existent domain")
+ log.I("command [getRule]")
+ out, err = self.pfw.sendCmd("getRule","Wrong_Domain_Name",self.conf_2)
+ assert err == None, "ERROR : command [getRule] - Error when getting rule from a non-existent domain"
+ assert out != "Done", "ERROR : command [getRule] - Error not detected while getting rule from a non-existent domain"
+ log.I("error correctly detected when getting rule from a non-existent domain")
+ log.I("getting a rule with wrong parameters order")
+ log.I("command [getRule]")
+ out, err = self.pfw.sendCmd("getRule",self.conf_1,self.domain_name)
+ assert err == None, "ERROR : command [getRule] - Error when getting a rule with incorrect paramaters order"
+ assert out != "Done", "ERROR : command [getRule] - Error not detected when getting a rule with incorrect paramaters order"
+ log.I("error correctly detected when getting a rule with incorrect paramaters order on domain %s and configuration %s" % (self.domain_name,self.conf_1))
+
+ # New domain deletion
+ log.I("Domain %s deletion" % (self.domain_name))
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+ log.I("Domain %s deleted" % (self.domain_name))
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal case
+ --------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - setting rules for configurations
+ - getting rules from configurations
+ - Clear created rules
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [getRule] function
+ - [setRule] function
+ - [clearRule] function
+ - [createDomain] function
+ - [createConfiguration] function
+ - [deleteConfiguration] function
+ - [deleteDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+ # New domain creation for testing purpose
+ log.I("New domain creation for testing purpose : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # New configurations creation for testing purpose
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_1,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_1)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_1)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_1,self.domain_name))
+ log.I("New configuration %s creation for domain %s for testing purpose" % (self.conf_2,self.domain_name))
+ log.I("command [createConfiguration]")
+ out, err = self.pfw.sendCmd("createConfiguration",self.domain_name,self.conf_2)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createConfiguration] - Error while creating configuration %s" % (self.conf_2)
+ log.I("command [createConfiguration] correctly executed")
+ log.I("Configuration %s created for domain %s" % (self.conf_2,self.domain_name))
+
+ # Applying rules to configurations
+ log.I("Applying rules to configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+ log.I("command [setRule]")
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_1,self.rule_1)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_1)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_1)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_1))
+ out, err = self.pfw.sendCmd("setRule",self.domain_name,self.conf_2,self.rule_2)
+ assert err == None, "ERROR : command [setRule] - Error while setting rule for configurations %s" % (self.conf_2)
+ assert out == "Done", "FAIL : command [setRule] - Error while setting rule for configuration %s" % (self.conf_2)
+ log.I("command [setRule] correctly executed")
+ log.I("rule correctly created for configuration %s" % (self.conf_2))
+
+ # Checking rules recovered
+ log.I("Recovering rules for configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+ log.I("command [getRule]")
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
+ assert err == None, "ERROR : command [getRule] - Error while setting rule to configurations %s" % (self.conf_1)
+ assert out == str(self.rule_1), "FAIL : command [getRule] - Error while recovering rule from configuration %s, incorrect value" % (self.conf_1)
+ log.I("command [getRule] correctly executed")
+ log.I("rule correctly recovered from configuration %s" % (self.conf_1))
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
+ assert err == None, "ERROR : command [getRule] - Error while setting rule to configurations %s" % (self.conf_2)
+ assert out == str(self.rule_2), "FAIL : command [getRule] - Error while recovering rule from configuration %s, incorrect value" % (self.conf_2)
+ log.I("command [getRule] correctly executed")
+ log.I("rule correctly recovered from configuration %s" % (self.conf_2))
+
+ # Clearing rules
+ log.I("Clear rules for configurations %s and %s from domain %s" % (self.conf_1,self.conf_2,self.domain_name))
+ log.I("command [clearRule]")
+ out, err = self.pfw.sendCmd("clearRule",self.domain_name,self.conf_1)
+ assert err == None, "ERROR : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_1)
+ assert out == "Done", "FAIL : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_1)
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_1)
+ assert out == "<none>", "ERROR : command [clearRule] - ClearRule not working for configuration %s" % (self.conf_1)
+ out, err = self.pfw.sendCmd("clearRule",self.domain_name,self.conf_2)
+ assert err == None, "ERROR : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_2)
+ assert out == "Done", "FAIL : command [clearRule] - Error on clearRule for configuration %s" % (self.conf_2)
+ out, err = self.pfw.sendCmd("getRule",self.domain_name,self.conf_2)
+ assert out == "<none>", "ERROR : command [clearRule] - ClearRule not working for configuration %s" % (self.conf_2)
+ log.I("command [clearRule] correctly executed")
+ log.I("ClearRule effective for configurations %s and %s" % (self.conf_1,self.conf_2))
+
+ # New domain deletion
+ log.I("Domain %s deletion" % (self.domain_name))
+ log.I("command [deleteDomain]")
+ out, err = self.pfw.sendCmd("deleteDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [deleteDomain] - Error while delting domain %s" % (self.domain_name)
+ log.I("command [deleteDomain] correctly executed")
+ log.I("Domain %s deleted" % (self.domain_name))
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_Split.py b/test/functional-tests/PfwTestCase/Domains/tDomain_Split.py
new file mode 100644
index 0000000..9d2990e
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_Split.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.
+
+"""
+Split elements from domains testcases
+
+List of tested functions :
+--------------------------
+ - [splitDomain] function
+ - [listBelongingDomains] function
+ - [listAssociatedDomains] function
+ - [listAssociatedElements] function
+ - [listConflictingElements] function
+ - [listRogueElements] function
+Test cases :
+------------
+ - Testing nominal case
+"""
+import os.path
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.reference_xml = "$PFW_TEST_TOOLS/xml/XML_Test/Reference_Split_Domain.xml"
+
+ self.temp_domain="f_Domains_Backup"
+ self.temp_status="f_Config_Status"
+
+ self.path_main = "/Test/Test/TEST_MAIN/"
+ self.path_dir_0 = "/Test/Test/TEST_MAIN/TEST_DIR_0"
+ self.path_dir_1 = "/Test/Test/TEST_MAIN/TEST_DIR_1"
+ self.path_dir_2 = "/Test/Test/TEST_MAIN/TEST_DIR_2"
+ self.dir_nbr = 3
+ self.element_name = "TEST_DIR"
+
+ self.domain_1 = "Domain_1"
+ self.domain_2 = "Domain_2"
+ self.domain_3 = "Domain_3"
+
+ self.temp_file="f_temp_file"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+ if os.path.exists(self.temp_file):
+ os.remove(self.temp_file)
+ def test_Combinatorial_Criteria(self):
+ """
+ Testing combinatorial criteria
+ ------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Split a configuration element associated to a domain
+ - Check that the configuration element children are associated to the domain
+ - Pass a configuration element to rogue element
+ - Add a configuration element to another domain and heck that this element is
+ conflicting while not removed from original domain.
+
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [splitDomain] function
+ - [listBelongingDomains] function
+ - [listAssociatedDomains] function
+ - [listAssociatedElements] function
+ - [listConflictingElements] function
+ - [listRogueElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Conform to expected behavior
+ """
+ log.D(self.test_Combinatorial_Criteria.__doc__)
+
+ # Import a reference XML file
+ log.I("Import Domains with settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ # Checking initial state
+ # Checking domain integrity
+ log.I("Checking initial conditions :")
+ log.I("Checking that %s configurable element is associated to %s :" % (self.path_main,self.domain_1))
+ out, err = self.pfw.sendCmd("listAssociatedDomains", self.path_main)
+ assert err == None, log.E("Command [listAssociatedDomains] : error when listing domain name")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ element_name = self.domain_1
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if element_name in line:
+ element_found = 1
+ assert element_found==1, log.F("configurable element %s not correctly associated to domain %s" % (self.path_main, self.domain_1))
+ log.I("configurable element %s correctly associated to domain %s" % (self.path_main, self.domain_1))
+ # Deleting temp file
+ os.remove(self.temp_file)
+
+ # Checking children integrity
+ log.I("Checking that %s children configurable elements are correctly set for the test" % (self.path_main))
+ out, err = self.pfw.sendCmd("listElements", self.path_main)
+ assert err == None, log.E("Command [listElements] : listing error")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ for index in range (self.dir_nbr):
+ element_name = "".join([self.element_name, "_", str(index)])
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if element_name in line:
+ element_found = 1
+ assert element_found==1, log.F("Element %s not found in %s" % (element_name, self.path_main))
+ log.I("Element %s found in %s" % (element_name, self.path_main))
+ # Checking that child element belong to domain
+ element_path = "".join([self.path_main, element_name])
+ out, err = self.pfw.sendCmd("listBelongingDomains", element_path)
+ assert err == None, log.E("Command [listBelongingDomains] : listing error")
+ assert out == self.domain_1, log.F("Wrong behavior : %s not belonging to %s " % (element_name, self.domain_1))
+ # Checking that child element is not associated to domain, and only belong to it
+ out, err = self.pfw.sendCmd("listAssociatedDomains", element_path)
+ assert err == None, log.E("Command [listAssociatedDomains] : listing error")
+ assert out == '', log.F("Wrong behavior : configurable element %s not associated to %s" % (element_name, self.domain_1))
+ log.I("configurable element %s is belonging to %s" % (element_name, self.domain_1))
+ log.I("Configurable elements : check OK")
+ # Deleting temp file
+ os.remove(self.temp_file)
+
+ # Split domain_0
+ log.I("Splitting configurable element %s from %s" % (self.path_main, self.domain_1))
+ out, err = self.pfw.sendCmd("splitDomain", self.domain_1, self.path_main)
+ assert err == None, log.E("Command [splitDomain] : %s" % (err))
+ assert out == 'Done', log.F("Wrong behavior : configurable element %s not splitted correctly" % (self.path_main))
+ log.I("Splitting done")
+
+ # check that the configurable element splitted is neither associated nor belonging to the domain
+ log.I("Checking that %s is neither associated nor belonging to %s" % (self.path_main, self.domain_1))
+ out, err = self.pfw.sendCmd("listBelongingDomains", self.path_main)
+ assert err == None, log.E("Command [listBelongingDomains] : listing error")
+ assert out != self.domain_1, log.F("Wrong behavior : %s still belonging to %s" % (self.path_main, self.domain_1))
+ out, err = self.pfw.sendCmd("listAssociatedDomains", self.path_main)
+ assert err == None, log.E("Command [listAssociatedDomains] : listing error")
+ assert out == '', log.F("Wrong behavior : configurable element %s still associated to %s" % (self.path_main, self.domain_1))
+ log.I("Configurable element %s is no longer associated to %s" % (self.path_main, self.domain_1))
+
+ # Checking that children configurable elements are now associated to domain
+ log.I("Checking that %s children configurable elements are now associated to %s" % (self.path_main, self.domain_1))
+ out, err = self.pfw.sendCmd("listElements", self.path_main)
+ assert err == None, log.E("Command [listElements] : listing error")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ for index in range (self.dir_nbr):
+ element_name = "".join([self.element_name, "_", str(index)])
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if element_name in line:
+ element_found = 1
+ assert element_found==1, log.F("Element %s not found in %s" % (element_name, self.path_main))
+ log.I("Element %s found in %s" % (element_name, self.path_main))
+ # Checking that child element is associated to domain
+ element_path = "".join([self.path_main, element_name])
+ out, err = self.pfw.sendCmd("listAssociatedDomains", element_path)
+ assert err == None, log.E("Command [listAssociatedDomains] : listing error")
+ assert out == self.domain_1, log.F("Wrong behavior : configurable element %s not associated to %s" % (element_name, self.domain_1))
+ log.I("configurable element %s is associated to %s" % (element_name, self.domain_1))
+ log.I("Configurable elements : check OK")
+ # Deleting temp file
+ os.remove(self.temp_file)
+
+ # Removing one element from domain and checking that it becomes a rogue element
+ log.I("Removing domain element %s from domain %s" % (self.path_dir_0, self.domain_1))
+ out, err = self.pfw.sendCmd("removeElement", str(self.domain_1), str(self.path_dir_0))
+ assert err == None, log.E("ERROR : command [removeElement] - Error while removing domain element %s" % (self.path_dir_0))
+ assert out == "Done", log.F("Domain element %s not correctly removed" % (self.path_dir_0))
+ log.I("Domain element %s correctly removed from domain %s" % (self.path_dir_0, self.domain_1))
+ log.I("Checking that %s is a rogue element" % (self.path_dir_0))
+ out, err = self.pfw.sendCmd("listRogueElements")
+ assert err == None, log.E("command [listRogueElements] - Error while listing rogue elements")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if self.path_dir_0 in line:
+ element_found = 1
+ assert element_found==1, log.F("Configurable element %s not found in rogue elements" % (self.path_dir_0))
+ log.I("Element %s found in rogue elements" % (self.path_dir_0))
+
+ # Moving one configuration element to another domain
+ log.I("Moving configurable element %s from domain %s to domain %s" % (self.path_dir_1, self.domain_1, self.domain_2))
+ log.I("Adding %s to domain %s" % (self.path_dir_1, self.domain_2))
+ out, err = self.pfw.sendCmd("addElement", self.domain_2, self.path_dir_1)
+ assert err == None, log.E("ERROR : command [addElement] - Error while adding element %s to domain %s" % (self.path_dir_1, self.domain_2))
+ out, err = self.pfw.sendCmd("listConflictingElements")
+ assert err == None, log.E("command [listConflictingElements] - Error while listing conflicting elements")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if self.path_dir_1 in line:
+ element_found = 1
+ assert element_found==1, log.F("Configurable element %s not found in conflicting elements" % (self.path_dir_1))
+ log.I("Element %s found in conflicting elements" % (self.path_dir_1))
+ log.I("Removing %s from domain %s" % (self.path_dir_1, self.domain_1))
+ out, err = self.pfw.sendCmd("removeElement", self.domain_1, self.path_dir_1)
+ assert err == None, log.E("ERROR : command [removeElement] - Error while removing element %s from domain %s" % (self.path_dir_1, self.domain_2))
+ out, err = self.pfw.sendCmd("listConflictingElements")
+ assert err == None, log.E("command [listConflictingElements] - Error while listing conflicting elements")
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+ element_found = 0
+ for line in open(self.temp_file, "r"):
+ if self.path_dir_1 in line:
+ element_found = 1
+ assert element_found!=1, log.F("Configurable element %s still found in conflicting elements" % (self.path_dir_1))
+ log.I("Element %s no longer found in conflicting elements" % (self.path_dir_1))
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_creation_deletion.py b/test/functional-tests/PfwTestCase/Domains/tDomain_creation_deletion.py
new file mode 100644
index 0000000..039830d
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_creation_deletion.py
@@ -0,0 +1,344 @@
+# -*-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.
+
+"""
+Creation, renaming and deletion configuration testcases
+
+List of tested functions :
+--------------------------
+ - [createDomain] function
+ - [deleteDomain] function
+
+Test cases :
+------------
+ - Testing nominal cases
+ - Testing domain creation error
+ - Testing domain deletion error
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of Domains - Basic operations (creations/deletions)
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.new_domains_number = 4
+ self.new_domain_name = "Domain"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Domain_Creation_Error(self):
+ """
+ Testing domain creation error
+ -----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Create an already existent domain
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [createDomain] function
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Error detected when creating an already existent domain
+ - No domains list update
+ """
+ log.D(self.test_Domain_Creation_Error.__doc__)
+ # New domain creation
+ log.I("New domain creation")
+ log.I("command [createDomain]")
+ domain_name = 'Test_Domain'
+ out, err = self.pfw.sendCmd("createDomain",domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (domain_name)
+ log.I("command [createDomain] correctly executed")
+
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] - correctly executed")
+
+ # Domains listing backup
+ f_Domains_Backup = open("f_Domains_Backup", "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open("f_Domains_Backup", "r")
+ domains_nbr_init = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr_init+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr_init)
+
+ # Trying to add an existent domain name
+ log.I("Adding an already existent domain name")
+ log.I("command [createDomain]")
+ domain_name = 'Test_Domain'
+ out, err = self.pfw.sendCmd("createDomain",domain_name, "")
+ assert out != "Done", "ERROR : command [createDomain] - Error not detected when creating an already existent domain"
+ assert err == None, err
+ log.I("command [createDomain] - error correctly detected")
+
+ # Checking domains list integrity
+ log.I("Checking domains listing integrity after domain creation error")
+ ## Domains listing using "listDomains" command
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ f_Domains = open("f_Domains", "w")
+ f_Domains.write(out)
+ f_Domains.close()
+ ## Domains listing integrity check
+ f_Domains = open("f_Domains", "r")
+ domains_nbr = 0
+ line=f_Domains.readline()
+ while line!="":
+ line=f_Domains.readline()
+ domains_nbr+=1
+ f_Domains.close()
+ assert domains_nbr == domains_nbr_init, "ERROR : Domains number error, expected %s, found %s" % (domains_nbr_init,domains_nbr)
+ log.I("Test OK - Domains number not updated")
+ f_Domains = open("f_Domains", "r")
+ f_Domains_Backup = open("f_Domains_Backup", "r")
+ for line in range(domains_nbr):
+ domain_backup_name = f_Domains_Backup.readline().strip('\n'),
+ domain_name = f_Domains.readline().strip('\n'),
+ assert domain_backup_name==domain_name, "ERROR : Error while reading domain %s" % (domain_backup_name)
+ log.I("Test OK - Domains listing not affected by domain creation error")
+
+ # Closing and deleting temp files
+ f_Domains_Backup.close()
+ f_Domains.close()
+ os.remove("f_Domains_Backup")
+ os.remove("f_Domains")
+
+ def test_Domain_Deletion_Error(self):
+ """
+ Testing domain deletion error
+ -----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Delete a non existent domain
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [deleteDomain] function
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - Error detected when deleting a non-existent domain
+ - No domains list update
+ """
+ log.D(self.test_Domain_Deletion_Error.__doc__)
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+
+ # Domains listing backup
+ f_Domains_Backup = open("f_Domains_Backup", "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open("f_Domains_Backup", "r")
+ domains_nbr_init = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr_init+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr_init)
+
+ # Trying to delete a non-existent domain name
+ log.I("Deleting a non-existent domain name")
+ log.I("command [deleteDomain]")
+ domain_name = 'Wrong_Domain_Name'
+ out, err = self.pfw.sendCmd("deleteDomain",domain_name, "")
+ assert out != "Done", "ERROR : command [deleteDomain] - Error not detected when deleting a non-existent domain"
+ assert err == None, err
+ log.I("command [deleteDomain] - error correctly detected")
+
+ # Checking domains list integrity
+ log.I("Checking domains listing integrity after domain deletion error")
+ ## Domains listing using "listDomains" command
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ f_Domains = open("f_Domains", "w")
+ f_Domains.write(out)
+ f_Domains.close()
+ ## Domains listing integrity check
+ f_Domains = open("f_Domains", "r")
+ domains_nbr = 0
+ line=f_Domains.readline()
+ while line!="":
+ line=f_Domains.readline()
+ domains_nbr+=1
+ f_Domains.close()
+ assert domains_nbr == domains_nbr_init, "ERROR : Domains number error, expected %s, found %s" % (domains_nbr_init,domains_nbr)
+ log.I("Test OK - Domains number not updated")
+ f_Domains = open("f_Domains", "r")
+ f_Domains_Backup = open("f_Domains_Backup", "r")
+ for line in range(domains_nbr):
+ domain_backup_name = f_Domains_Backup.readline().strip('\n'),
+ domain_name = f_Domains.readline().strip('\n'),
+ assert domain_backup_name==domain_name, "Error while reading domain %s" % (domain_backup_name)
+ log.I("Test OK - Domains listing not affected by domain deletion error")
+
+ # Closing and deleting temp files
+ f_Domains_Backup.close()
+ f_Domains.close()
+ os.remove("f_Domains_Backup")
+ os.remove("f_Domains")
+
+ def test_Nominal_Case(self):
+ """
+ Testing nominal cases
+ ---------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Create X new domains
+ - Delete X domains
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [createDomain] function
+ - [deleteDomain] function
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - X new domains created
+ - X domains deleted
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+ # Initial domains listing using "listDomains" command
+ log.I("Initial domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+
+ # Initial domains number count
+ f_init_domains = open("f_init_domains", "w")
+ f_init_domains.write(out)
+ f_init_domains.close()
+ init_domains_nbr = 0
+ f_init_domains = open("f_init_domains", "r")
+ line=f_init_domains.readline()
+ while line!="":
+ line=f_init_domains.readline()
+ init_domains_nbr+=1
+ f_init_domains.close()
+ log.I("Initial domains number : %s" % (init_domains_nbr))
+
+ # New domains creation
+ log.I("New domains creation")
+ log.I("PFW command : [createDomain]")
+ for index in range (self.new_domains_number):
+ domain_name = "".join([self.new_domain_name, "_", str(index+init_domains_nbr)])
+ out, err = self.pfw.sendCmd("createDomain",domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (domain_name)
+ log.I("command [createDomain] correctly executed")
+
+ # New domain creation check
+ log.I("New domains creation check :")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing new domains"
+ log.I("command [listDomains] correctly executed")
+
+ # Working on a temporary files to record domains listing
+ tempfile = open("tempfile", "w")
+ tempfile.write(out)
+ tempfile.close()
+
+ # Checking last added entries in the listing
+ tempfile = open("tempfile", "r")
+ domains_nbr = 0
+ line=tempfile.readline()
+ while line!="":
+ line=tempfile.readline()
+ domains_nbr+=1
+ tempfile.close()
+ log.I("New domains conformity check")
+ tempfile = open("tempfile", "r")
+ for line in range(domains_nbr):
+ if (line >= (domains_nbr - self.new_domains_number)):
+ domain_name = "".join([self.new_domain_name,"_",str(line)]),
+ domain_created = tempfile.readline().strip('\n'),
+ assert domain_name==domain_created, "ERROR : Error while creating domain %s %s" % (domain_created, domain_name)
+ else:
+ domain_created = tempfile.readline()
+ log.I("New domains conform to expected values")
+ created_domains_number = domains_nbr - init_domains_nbr
+ log.I("%s new domains created" % created_domains_number)
+ tempfile.close()
+ os.remove("tempfile")
+
+ # New domains deletion
+ log.I("New domains deletion")
+ log.I("command [deleteDomain]")
+ for index in range (self.new_domains_number):
+ domain_name = "".join([self.new_domain_name, "_", str(index+init_domains_nbr)])
+ out, err = self.pfw.sendCmd("deleteDomain",domain_name, "")
+ assert out == "Done", "ERROR : %s" % (out)
+ assert err == None, "ERROR : command [deleteDomain] - Error while deleting domain %s" % (domain_name)
+ log.I("command [deleteDomain] correctly executed")
+
+ # New domains deletion check
+ f_init_domains = open("f_init_domains", "r")
+ tempfile = open("tempfile", "w")
+ log.I("New domains deletion check :")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ tempfile.write(out)
+ tempfile.close()
+ tempfile = open("tempfile", "r")
+ line=tempfile.readline()
+ line_init=f_init_domains.readline()
+ while line!="":
+ line=tempfile.readline()
+ line_init=f_init_domains.readline()
+ assert line == line_init, "ERROR : Domain deletion error"
+ if line=="":
+ assert line_init == "", "ERROR : Wrong domains deletion number"
+ log.I("Deletion completed - %s domains deleted" % created_domains_number)
+
+ # Temporary files deletion
+ tempfile.close()
+ f_init_domains.close()
+ os.remove("tempfile")
+ os.remove("f_init_domains")
diff --git a/test/functional-tests/PfwTestCase/Domains/tDomain_rename.py b/test/functional-tests/PfwTestCase/Domains/tDomain_rename.py
new file mode 100644
index 0000000..81d4539
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Domains/tDomain_rename.py
@@ -0,0 +1,337 @@
+# -*-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.
+
+"""
+Renaming domains testcases
+
+List of tested functions :
+--------------------------
+ - [renameDomain] function
+
+Test cases :
+------------
+ - Nominal cases
+ - Renaming errors
+ - Special cases
+"""
+import os
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+# Test of Domains - Rename
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "domain_white"
+ self.new_domain_name = "domain_black"
+ self.renaming_iterations = 5
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Nominal_Case(self):
+ """
+ Nominal case
+ ------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - Renaming a domain
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [renameDomain] function
+ - [createDomain] function
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - domains correctly renamed
+ """
+ log.D(self.test_Nominal_Case.__doc__)
+ # New domain creation
+ log.I("New domain creation : %s" % (self.domain_name))
+ log.I("command [createDomain]" )
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - ERROR while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] correctly executed")
+ log.I("Domain %s created" % (self.domain_name))
+
+ # Initial domains listing using "listDomains" command
+ log.I("Creating a domains listing backup")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "INFO : command [listDomains] - ERROR while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving initial domains names
+ f_init_domains = open("f_init_domains", "w")
+ f_init_domains.write(out)
+ f_init_domains.close()
+ log.I("Domains listing backup created")
+
+ # Checking domains number
+ f_init_domains = open("f_init_domains", "r")
+ domains_nbr = 0
+ line=f_init_domains.readline()
+ while line!="":
+ line=f_init_domains.readline()
+ domains_nbr+=1
+ f_init_domains.close()
+ os.remove("f_init_domains")
+ log.I("%s domains names saved" % domains_nbr)
+
+ # Domain renaming iterations
+ log.I("Checking domain renaming - %s iterations" % self.renaming_iterations)
+ old_name = self.domain_name
+ new_name = self.new_domain_name
+ for iteration in range (self.renaming_iterations):
+ log.I("Iteration %s" % (iteration))
+ log.I("Renaming domain %s to %s" % (old_name,new_name))
+ log.I("command [renameDomain]")
+ out, err = self.pfw.sendCmd("renameDomain",old_name,new_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [renameDomain] - ERROR while renaming domain %s" % (old_name)
+ # Domains listing using "listDomains" command
+ log.I("Creating a domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - ERROR while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving domains names
+ f_domains = open("f_domains", "w")
+ f_domains.write(out)
+ f_domains.close()
+ log.I("Domains listing created")
+ # Checking renaming
+ log.I("Checking that renaming is correct in domains listing")
+ f_domains = open("f_domains", "r")
+ for line in range(domains_nbr):
+ if (line >= (domains_nbr - 1)):
+ domain_renamed = f_domains.readline().strip('\n')
+ assert domain_renamed==new_name, "ERROR : Error while renaming domain %s" % (old_name)
+ else:
+ f_domains.readline()
+ f_domains.close()
+ log.I("New domain name %s conform to expected value" % (new_name))
+ temp = old_name
+ old_name = new_name
+ new_name = temp
+ os.remove("f_domains")
+
+ def test_Renaming_Error(self):
+ """
+ Renaming errors
+ ---------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - renaming a non existent domain
+ - renaming a domain with an already existent domain name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [renameDomain] function
+ - [createDomain] function
+ - [renameDomain] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - error detected
+ - domains names remain unchanged
+ """
+ log.D(self.test_Renaming_Error.__doc__)
+ # New domains creation
+ log.I("New domain creation : %s" % (self.domain_name))
+ log.I("command [createDomain]")
+ out, err = self.pfw.sendCmd("createDomain",self.domain_name, "")
+ assert out == "Done", out
+ assert err == None, "ERROR : command [createDomain] - Error while creating domain %s" % (self.domain_name)
+ log.I("command [createDomain] - correctly executed")
+ log.I("command Domain %s created" % (self.domain_name))
+
+ # Initial domains listing using "listDomains" command
+ log.I("Creating a domains listing backup")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "INFO : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving initial domains names
+ f_init_domains = open("f_init_domains", "w")
+ f_init_domains.write(out)
+ f_init_domains.close()
+ log.I("Domains listing backup created")
+
+ # Checking domains number
+ f_init_domains = open("f_init_domains", "r")
+ domains_nbr = 0
+ line=f_init_domains.readline()
+ while line!="":
+ line=f_init_domains.readline()
+ domains_nbr+=1
+ f_init_domains.close()
+ log.I("%s domains names saved" % domains_nbr)
+
+ # Domain renaming error : renamed domain does not exist
+ log.I("Renaming a non existent domain")
+ log.I("Renaming domain FAKE to NEW_NAME")
+ log.I("command [renameDomain]")
+ out, err = self.pfw.sendCmd("renameDomain",'FAKE','NEW_NAME')
+ assert out != "Done", out
+ assert err == None, "ERROR : command [renameDomain] - Error while renaming domain"
+ log.I("command [renameDomain] - renaming error correctly detected")
+ # Domains listing using "listDomains" command
+ log.I("Creating a domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving domains names
+ f_domains = open("f_domains", "w")
+ f_domains.write(out)
+ f_domains.close()
+ log.I("Domains listing created")
+ # Checking domains names integrity
+ log.I("Checking domains names integrity")
+ f_domains = open("f_domains", "r")
+ f_init_domains = open("f_init_domains", "r")
+ for line in range(domains_nbr):
+ domain_name = f_domains.readline().strip('\n')
+ domain_backup_name = f_init_domains.readline().strip('\n')
+ assert domain_name==domain_backup_name, "ERROR : Domain name %s affected by the renaming error" % (domain_backup_name)
+ f_domains.close()
+ f_init_domains.close()
+ log.I("Domains names not affected by the renaming error")
+ os.remove("f_domains")
+
+ # Domain renaming error : renaming a domain with an already existent domain name
+ log.I("renaming a domain with an already existent domain name")
+ log.I("Renaming domain %s to %s" % (self.domain_name,self.new_domain_name) )
+ log.I("command [renameDomain]")
+ out, err = self.pfw.sendCmd("renameDomain",self.domain_name,self.new_domain_name)
+ assert out != "Done", out
+ assert err == None, "INFO : command [renameDomain] - Error while renaming domain"
+ log.I("command [renameDomain] - renaming error correctly detected")
+ # Domains listing using "listDomains" command
+ log.I("Creating a domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving domains names
+ f_domains = open("f_domains", "w")
+ f_domains.write(out)
+ f_domains.close()
+ log.I("Domains listing created")
+ # Checking domains names integrity
+ log.I("Checking domains names integrity")
+ f_domains = open("f_domains", "r")
+ f_init_domains = open("f_init_domains", "r")
+ for line in range(domains_nbr):
+ domain_name = f_domains.readline().strip('\n')
+ domain_backup_name = f_init_domains.readline().strip('\n')
+ assert domain_name==domain_backup_name, "ERROR : domain name %s affected by the renaming error" % (domain_backup_name)
+ f_domains.close()
+ f_init_domains.close()
+ log.I("Domains names not affected by the renaming error")
+ os.remove("f_domains")
+ os.remove("f_init_domains")
+
+ def test_Special_Cases(self):
+ """
+ Special cases
+ -------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - renaming a domain with its own name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [renameDomain] function
+ - [createDomain] function
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - no error
+ - domains names remain unchanged
+ """
+ log.D(self.test_Special_Cases.__doc__)
+ # New domain creation
+ # Already created in previous test
+
+ # Initial domains listing using "listDomains" command
+ log.I("Creating a domains listing backup")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving initial domains names
+ f_init_domains = open("f_init_domains", "w")
+ f_init_domains.write(out)
+ f_init_domains.close()
+ log.I("Domains listing backup created")
+
+ # Checking domains number
+ f_init_domains = open("f_init_domains", "r")
+ domains_nbr = 0
+ line=f_init_domains.readline()
+ while line!="":
+ line=f_init_domains.readline()
+ domains_nbr+=1
+ f_init_domains.close()
+ log.I("%s domains names saved" % domains_nbr)
+
+ # Domain renaming error : renaming a domain with its own name
+ log.I("renaming a domain with its own name")
+ log.I("Renaming domain %s to %s" % (self.domain_name,self.domain_name))
+ log.I("command [renameDomain]")
+ out, err = self.pfw.sendCmd("renameDomain",self.domain_name,self.domain_name)
+ assert out == "Done", out
+ assert err == None, "ERROR : command [renameDomain] - Error while renaming domain"
+ log.I("command [renameDomain] correctly executed")
+ # Domains listing using "listDomains" command
+ log.I("Creating a domains listing")
+ log.I("command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, "ERROR : command [listDomains] - Error while listing domains"
+ log.I("command [listDomains] correctly executed")
+ # Saving domains names
+ f_domains = open("f_domains", "w")
+ f_domains.write(out)
+ f_domains.close()
+ log.I("Domains listing created")
+ # Checking domains names integrity
+ log.I("Checking domains names integrity")
+ f_domains = open("f_domains", "r")
+ f_init_domains = open("f_init_domains", "r")
+ for line in range(domains_nbr):
+ domain_name = f_domains.readline().strip('\n')
+ domain_backup_name = f_init_domains.readline().strip('\n')
+ assert domain_name==domain_backup_name, "ERROR : domain name %s affected by the renaming" % (domain_backup_name)
+ f_domains.close()
+ f_init_domains.close()
+ log.I("Domains names not affected by the renaming")
+
+ os.remove("f_domains")
+ os.remove("f_init_domains")
diff --git a/test/functional-tests/PfwTestCase/Functions/__init__.py b/test/functional-tests/PfwTestCase/Functions/__init__.py
new file mode 100644
index 0000000..7b72df8
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/__init__.py
@@ -0,0 +1,9 @@
+"""
+Functions Package : All testcases about main functions in PFW :
+ - listing functions
+ - help function
+ - status function
+ - export/import functions
+ - get/set parameter functions
+ - synchronization functions
+""" \ No newline at end of file
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py b/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py
new file mode 100644
index 0000000..847ed47
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_Export_Import_Domains.py
@@ -0,0 +1,1143 @@
+# -*-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.
+
+"""
+Export and import settings and domains from file testcases
+
+List of tested functions :
+--------------------------
+ - [exportDomainsWithSettingsXML] function
+ - [importDomainsWithSettingsXML] function
+ - [exportDomainsXML] function
+ - [importDomainsXML] function
+ - [importSettings] function
+ - [exportSettings] function
+
+Test cases :
+------------
+ - Testing importDomainsWithSettingsXML nominal case
+ - Testing exportDomainsWithSettingsXML nominal case
+ - Testing exportDomainsXML/importDomainsXML nominal case
+ - Testing importSettings/exportSettings nominal case
+ - Testing import errors
+ - Testing export errors
+"""
+import os, commands
+import unittest
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+
+ def setUp(self):
+
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.param_name_01 = "/Test/Test/TEST_DIR/UINT16"
+ self.filesystem_01 = "$PFW_FILESYSTEM/UINT16"
+ self.param_name_02 = "/Test/Test/TEST_DOMAIN_0/Param_00"
+ self.filesystem_02 = "$PFW_FILESYSTEM/Param_00"
+ self.param_name_03 = "/Test/Test/TEST_DOMAIN_1/Param_12"
+ self.filesystem_03 = "$PFW_FILESYSTEM/Param_12"
+
+ pfw_test_tools=os.getenv("PFW_TEST_TOOLS")
+ self.reference_xml = pfw_test_tools+"/xml/XML_Test/Reference_Compliant.xml"
+ self.initial_xml = pfw_test_tools+"/xml/TestConfigurableDomains.xml"
+ self.temp_config="f_Config_Backup"
+ self.temp_domain="f_Domains_Backup"
+ self.temp_xml=pfw_test_tools+"/f_temp.xml"
+ self.temp_binary=pfw_test_tools+"/f_temp.binary"
+
+ self.nb_domains_in_reference_xml=3
+ self.nb_conf_per_domains_in_reference_xml=[2,2,2]
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+ if os.path.exists(self.temp_domain):
+ os.remove(self.temp_domain)
+ if os.path.exists(self.temp_config):
+ os.remove(self.temp_config)
+ if os.path.exists(self.temp_xml):
+ os.remove(self.temp_xml)
+ if os.path.exists(self.temp_binary):
+ os.remove(self.temp_binary)
+
+ def test_01_importDomainsWithSettingsXML_Nominal_Case(self):
+ """
+ Testing importDomainsWithSettingsXML nominal case
+ -------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - import a reference XML
+ - check Domains
+ - check Configuration
+ - restore Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [createConfiguration] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_01_importDomainsWithSettingsXML_Nominal_Case.__doc__)
+
+ #Import a reference XML file
+ log.I("Import Domains with settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared)
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ log.I("Command [listDomains] - correctly executed")
+ # Domains listing backup
+ f_Domains_Backup = open(self.temp_domain, "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open(self.temp_domain, "r")
+ domains_nbr = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr)
+ assert domains_nbr==self.nb_domains_in_reference_xml, log.F("Number of listed domains is not compliant with the file %s - expected : %s - found : %s"%(self.reference_xml,self.nb_domains_in_reference_xml, domains_nbr))
+
+ #Check number of config per domain(2 config per domains are setup in the reference XML)
+ # Config listing
+ domain_basename="Domain_"
+ for index in range(self.nb_domains_in_reference_xml):
+ domain_name=domain_basename+str(index+1)
+ log.I("Listing config for domain %s"%(domain_name))
+ out, err = self.pfw.sendCmd("listConfigurations",domain_name,"")
+ assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err))
+ log.I("Command [listConfigurations %s] - correctly executed"%(domain_name))
+ f_Config_Backup = open(self.temp_config, "w")
+ f_Config_Backup.write(out)
+ f_Config_Backup.close()
+ f_Config_Backup = open(self.temp_config, "r")
+ config_nbr = 0
+ line=f_Config_Backup.readline()
+ while line!="":
+ line=f_Config_Backup.readline()
+ config_nbr+=1
+ f_Config_Backup.close()
+ assert config_nbr==self.nb_conf_per_domains_in_reference_xml[index], log.F("Number of listed config for %s is not compliant with the file %s - expected : %s - found : %s"%(domain_name, self.reference_xml,self.nb_conf_per_domains_in_reference_xml[index], domains_nbr))
+ log.I("Config checking : OK")
+
+ #Check number of config per domain(2 config per domains are setup in the reference XML)
+ # Config listing
+ conf_basename="Conf_"
+ for index_domain in range(3):
+ for index_conf in range(2):
+ domain_name=domain_basename+str(index_domain+1)
+ conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf)
+ log.I("Get rule for domain %s - conf %s"%(domain_name,conf_name))
+ out, err = self.pfw.sendCmd("getRule",domain_name,conf_name)
+ assert err == None, log.E("Command [getRules %s %s] : %s"%(domain_name,conf_name,err))
+ assert out !="", log.F("No rules loaded for domain %s conf %s"%(domain_name,conf_name))
+ log.I("Rules checking : OK")
+
+ #Restore config
+ conf_basename="Conf_"
+ for index_domain in range(3):
+ for index_conf in range(2):
+ domain_name=domain_basename+str(index_domain+1)
+ conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf)
+ log.I("Restore config %s for domain %s"%(conf_name,domain_name))
+ out, err = self.pfw.sendCmd("restoreConfiguration",domain_name,conf_name)
+ assert err == None, log.E("Command [restoreConfiguration %s %s] : %s"%(domain_name,conf_name,err))
+ assert out =="Done", log.F("When restoring configuration %s for domain %s"%(conf_name,domain_name))
+ log.I("Restore configurations: OK")
+
+ #set Tuning Mode off to check parameter value
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ #Check parameter values
+ #UINT16
+ expected_value="0"
+ hex_value="0x0"
+ log.I("UINT16 parameter in the conf Conf_1_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value="4"
+ hex_value="0x4"
+ log.I("Param_00 parameter in the conf Conf_2_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value="4"
+ hex_value="0x4"
+ log.I("Param_12 parameter in the conf Conf_3_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+ log.I("Parameters checking : OK")
+
+ def test_02_exportDomainsWithSettingsXML_Nominal_Case(self):
+ """
+ Testing exportDomainsWithSettingsXML nominal case
+ -------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - export domains with settings in temp XML
+ - import a reference XML
+ - restore Configuration
+ - import the temp XML
+ - restore Configuration
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [exportDomainsWithSettingsXML] function
+ - [importDomainsWithSettingsXML] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_02_exportDomainsWithSettingsXML_Nominal_Case.__doc__)
+
+ ### INIT Domains Settings ####
+
+ #Import a reference XML file
+
+ log.I("Import Domains with initial settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+
+ ### END OF INIT ###
+
+ #Export in a temp XML file
+ log.I("Export Domains with initial settings in %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("exportDomainsWithSettingsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [exportDomainsWithSettingsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function exportDomainsWithSettingsXML %s]"%(self.temp_xml))
+
+ #Change the value of checked parameters
+ self.pfw.sendCmd("setTuningMode", "on","")
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_01, str(int(init_value_01)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_02, str(int(init_value_02)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_03, str(int(init_value_03)+1))
+ #save config
+ domain_basename="Domain_"
+ conf_basename="Conf_"
+ for index_domain in range(3):
+ for index_conf in range(2):
+ domain_name=domain_basename+str(index_domain+1)
+ conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf)
+ log.I("Save config %s for domain %s"%(conf_name,domain_name))
+ out, err = self.pfw.sendCmd("saveConfiguration",domain_name,conf_name)
+ assert err == None, log.E("Command [saveConfiguration %s %s] : %s"%(domain_name,conf_name,err))
+ assert out =="Done", log.F("When saving configuration %s for domain %s"%(conf_name,domain_name))
+ log.I("Save configurations: OK")
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ expected_value=str(int(init_value_01)+1)
+ log.I("UINT16 parameter = %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=str(int(init_value_02)+1)
+ log.I("Param_00 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=str(int(init_value_03)+1)
+ log.I("Param_12 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ #Import the temp XML file
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import Domains with settings from %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.temp_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ expected_value=init_value_01
+ log.I("UINT16 parameter = %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=init_value_02
+ log.I("Param_00 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=init_value_03
+ log.I("Param_12 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ def test_03_exportImportXML_withoutSettings_Nominal_Case(self):
+ """
+ Testing exportDomainsXML/importDomainsXML nominal case
+ ------------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - export domains in temp XML
+ - import a reference XML
+ - restore Configuration
+ - import the temp XML
+ - restore Configuration
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [exportDomainsXML] function
+ - [importDomainsWithSettingsXML] function
+ - [importDomainsXML] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ - parameter must not change
+ """
+ log.D(self.test_03_exportImportXML_withoutSettings_Nominal_Case.__doc__)
+
+ ### INIT Domains Settings ####
+
+ #Import a reference XML file
+
+ log.I("Import Domains with initial settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+
+ ### END OF INIT ###
+
+ #Export domains without settings in a temp XML file
+ log.I("Export Domains without initial settings in %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("exportDomainsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [exportDomainsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function exportDomainsXML %s]"%(self.temp_xml))
+
+ #Change the value of checked parameters
+ self.pfw.sendCmd("setTuningMode", "on","")
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_01, str(int(init_value_01)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_02, str(int(init_value_02)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_03, str(int(init_value_03)+1))
+ #save config
+ domain_basename="Domain_"
+ conf_basename="Conf_"
+ for index_domain in range(3):
+ for index_conf in range(2):
+ domain_name=domain_basename+str(index_domain+1)
+ conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf)
+ log.I("Save config %s for domain %s"%(conf_name,domain_name))
+ out, err = self.pfw.sendCmd("saveConfiguration",domain_name,conf_name)
+ assert err == None, log.E("Command [saveConfiguration %s %s] : %s"%(domain_name,conf_name,err))
+ assert out =="Done", log.F("When saving configuration %s for domain %s"%(conf_name,domain_name))
+ log.I("Save configurations: OK")
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ expected_value=str(int(init_value_01)+1)
+ log.I("UINT16 parameter = %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=str(int(init_value_02)+1)
+ log.I("Param_00 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=str(int(init_value_03)+1)
+ log.I("Param_12 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ #Import the temp XML file without
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import Domains without settings from %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("importDomainsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function importDomainsXML %s]"%(self.temp_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ unexpected_value=init_value_01
+ log.I("UINT16 parameter = %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_01, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ unexpected_value=init_value_02
+ log.I("Param_00 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_02, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ unexpected_value=init_value_03
+ log.I("Param_12 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s"% (self.param_name_03, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ #Import the reference_XML file without settings
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import Domains without settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsXML %s]"%(self.reference_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ unexpected_value=init_value_01
+ log.I("UINT16 parameter = %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_01, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ unexpected_value=init_value_02
+ log.I("Param_00 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_02, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ unexpected_value=init_value_03
+ log.I("Param_12 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_03, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+
+
+ def test_04_exportImportSettings_Binary_Nominal_Case(self):
+ """
+ Testing exportSettings/importSettings nominal case
+ --------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - export settings in temp binary files
+ - import a reference XML
+ - restore Configuration
+ - import the temp binary files
+ - restore Configuration
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [exportSettings] function
+ - [importDomainsWithSettingsXML] function
+ - [importSettings] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all operations succeed
+ """
+ log.D(self.test_04_exportImportSettings_Binary_Nominal_Case.__doc__)
+ ### INIT Domains Settings ####
+
+ #Import a reference XML file
+
+ log.I("Import Domains with initial settings from %s"
+ %(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+
+ ### END OF INIT ###
+
+ #Export domains without settings in a temp XML file
+ log.I("Export Domains without initial settings in %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("exportDomainsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [exportDomainsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function exportDomainsXML %s]"%(self.temp_xml))
+ #Export settings in a binary temp file
+ log.I("Export settings in the binary files %s"%(self.temp_binary))
+ out, err = self.pfw.sendCmd("exportSettings",self.temp_binary, "")
+ assert err == None, log.E("Command [exportSettings %s] : %s"%(self.temp_binary,err))
+ assert out == "Done", log.F("When using function exportSettings %s]"%(self.temp_binary))
+
+ #Change the value of checked parameters
+ self.pfw.sendCmd("setTuningMode", "on","")
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_01, str(int(init_value_01)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_02, str(int(init_value_02)+1))
+ out, err = self.pfw.sendCmd("setParameter", self.param_name_03, str(int(init_value_03)+1))
+ #save config
+ domain_basename="Domain_"
+ conf_basename="Conf_"
+ for index_domain in range(3):
+ for index_conf in range(2):
+ domain_name=domain_basename+str(index_domain+1)
+ conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf)
+ log.I("Save config %s for domain %s"%(conf_name,domain_name))
+ out, err = self.pfw.sendCmd("saveConfiguration",domain_name,conf_name)
+ assert err == None, log.E("Command [saveConfiguration %s %s] : %s"%(domain_name,conf_name,err))
+ assert out =="Done", log.F("When saving configuration %s for domain %s"%(conf_name,domain_name))
+ log.I("Save configurations: OK")
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ expected_value=str(int(init_value_01)+1)
+ log.I("UINT16 parameter = %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=str(int(init_value_02)+1)
+ log.I("Param_00 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=str(int(init_value_03)+1)
+ log.I("Param_12 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ #Import the temp XML file without
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import Domains without settings from %s"%(self.temp_xml))
+ out, err = self.pfw.sendCmd("importDomainsXML",self.temp_xml, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(self.temp_xml,err))
+ assert out == "Done", log.F("When using function importDomainsXML %s]"%(self.temp_xml))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ unexpected_value=init_value_01
+ log.I("UINT16 parameter = %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_01, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ unexpected_value=init_value_02
+ log.I("Param_00 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_02, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ unexpected_value=init_value_03
+ log.I("Param_12 parameter= %s"%(unexpected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s"% (self.param_name_03, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+ #Import settings from the binary files
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import settings from %s"%(self.temp_binary))
+ out, err = self.pfw.sendCmd("importSettings",self.temp_binary, "")
+ assert err == None, log.E("Command [importSettings %s] : %s"%(self.temp_binary,err))
+ assert out == "Done", log.F("When using function importSettings %s]"%(self.temp_binary))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #Check parameter values
+ #UINT16
+ expected_value=init_value_01
+ log.I("UINT16 parameter = %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=init_value_02
+ log.I("Param_00 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=init_value_03
+ log.I("Param_12 parameter= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+
+
+
+ @unittest.expectedFailure
+ def test_05_Import_XML_With_Settings_Error_Case(self):
+ """
+ Testing importDomainsWithSettingsXML error case
+ -----------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - import with settings non-compliant XML
+ - import with settings a non-existing XML file
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ - [importDomainsXML] function
+ - [importSettings] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected, initial domains keep settings
+ """
+ log.D(self.test_05_Import_XML_With_Settings_Error_Case.__doc__)
+
+ ### INIT Domains Settings ####
+ #Import a reference XML file
+
+ log.I("Import Domains with initial settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ self.pfw.sendCmd("setTuningMode", "off","")
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+ xml_path="$PFW_TEST_TOOLS/xml/XML_Test/"
+ ### END OF INIT ###
+
+ self.pfw.sendCmd("setTuningMode", "on","")
+ #Import domains and settings from xml with outbound parameter value
+ xml_name="Uncompliant_OutboundParameter.xml"
+ log.I("Import %s with initial settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains and settings from xml using undeclared configurable element
+ xml_name="Uncompliant_UndeclaredConfigurableElement.xml"
+ log.I("Import %s with initial settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains and settings from xml using undeclared parameter
+ xml_name="Uncompliant_UndeclaredParameter.xml"
+ log.I("Import %s with initial settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains and settings from xml using wrong order of configurable element
+ xml_name="Uncompliant_UnorderConfigurableElement.xml"
+ log.I("Import %s with initial settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains and settings from unexistent xml
+ xml_name="Unexistent.xml"
+ log.I("Import %s with initial settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #### check domains and settings ####
+
+ #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared)
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ log.I("Command [listDomains] - correctly executed")
+ # Domains listing backup
+ f_Domains_Backup = open(self.temp_domain, "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open(self.temp_domain, "r")
+ domains_nbr = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr)
+ assert domains_nbr==self.nb_domains_in_reference_xml, log.F("Number of listed domains is not compliant with the file %s - expected : %s - found : %s"%(self.reference_xml,self.nb_domains_in_reference_xml, domains_nbr))
+ #Check number of config per domain(2 config per domains are setup in the reference XML)
+ # Config listing
+ domain_basename="Domain_"
+ for index in range(self.nb_domains_in_reference_xml):
+ domain_name=domain_basename+str(index+1)
+ log.I("Listing config for domain %s"%(domain_name))
+ out, err = self.pfw.sendCmd("listConfigurations",domain_name,"")
+ assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err))
+ log.I("Command [listConfigurations %s] - correctly executed"%(domain_name))
+ f_Config_Backup = open(self.temp_config, "w")
+ f_Config_Backup.write(out)
+ f_Config_Backup.close()
+ f_Config_Backup = open(self.temp_config, "r")
+ config_nbr = 0
+ line=f_Config_Backup.readline()
+ while line!="":
+ line=f_Config_Backup.readline()
+ config_nbr+=1
+ f_Config_Backup.close()
+ assert config_nbr==self.nb_conf_per_domains_in_reference_xml[index], log.F("Number of listed config for %s is not compliant with the file %s - expected : %s - found : %s"%(domain_name, self.reference_xml,self.nb_conf_per_domains_in_reference_xml[index], domains_nbr))
+ log.I("Config checking : OK")
+ #Check parameter values
+ #UINT16
+ expected_value=init_value_01
+ hex_value=init_filesystem_01
+ log.I("UINT16 parameter in the conf Conf_1_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=init_value_02
+ hex_value=init_filesystem_02
+ log.I("Param_00 parameter in the conf Conf_2_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=init_value_03
+ hex_value=init_filesystem_03
+ log.I("Param_12 parameter in the conf Conf_3_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+ log.I("Parameters checking : OK")
+
+ #### END check domains and settings ####
+
+
+ @unittest.expectedFailure
+ def test_06_Import_XML_Without_Settings_Error_Case(self):
+ """
+ Testing import XML without settings error case
+ ----------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - import non-compliant XML
+ - import a non-existing XML files
+ - import a reference XML
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ - [importDomainsXML] function
+ - [importSettings] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected, initial domains keep settings
+ """
+ log.D(self.test_06_Import_XML_Without_Settings_Error_Case.__doc__)
+
+ ### INIT Domains Settings ####
+ #Import a reference XML file
+
+ log.I("Import Domains with initial settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ self.pfw.sendCmd("setTuningMode", "off","")
+ xml_path="$PFW_TEST_TOOLS/xml/XML_Test/"
+ ### END OF INIT ###
+
+ self.pfw.sendCmd("setTuningMode", "on","")
+ #Import domains from xml with outbound parameter value
+ xml_name="Uncompliant_OutboundParameter.xml"
+ log.I("Import %s without settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains from xml using undeclared configurable element
+ xml_name="Uncompliant_UndeclaredConfigurableElement.xml"
+ log.I("Import %s without settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains from xml using undeclared parameter
+ #xml_name="Uncompliant_UndeclaredParameter.xml"
+ #log.I("Import %s without settings"%(xml_name))
+ #out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "")
+ #assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err))
+ #assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ #log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains from xml using wrong order of configurable element
+ xml_name="Uncompliant_UnorderConfigurableElement.xml"
+ log.I("Import %s without settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ #Import domains from unexistent xml
+ xml_name="Unexistent.xml"
+ log.I("Import %s without settings"%(xml_name))
+ out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "")
+ assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name))
+ log.I("Test OK : %s is not imported"%(xml_name))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #### check domains and settings ####
+
+ #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared)
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ log.I("Command [listDomains] - correctly executed")
+ # Domains listing backup
+ f_Domains_Backup = open(self.temp_domain, "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open(self.temp_domain, "r")
+ domains_nbr = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr)
+ assert domains_nbr==self.nb_domains_in_reference_xml, log.F("Number of listed domains is not compliant with the file %s - expected : %s - found : %s"%(self.reference_xml,self.nb_domains_in_reference_xml, domains_nbr))
+ #Check number of config per domain(2 config per domains are setup in the reference XML)
+ # Config listing
+ domain_basename="Domain_"
+ for index in range(self.nb_domains_in_reference_xml):
+ domain_name=domain_basename+str(index+1)
+ log.I("Listing config for domain %s"%(domain_name))
+ out, err = self.pfw.sendCmd("listConfigurations",domain_name,"")
+ assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err))
+ log.I("Command [listConfigurations %s] - correctly executed"%(domain_name))
+ f_Config_Backup = open(self.temp_config, "w")
+ f_Config_Backup.write(out)
+ f_Config_Backup.close()
+ f_Config_Backup = open(self.temp_config, "r")
+ config_nbr = 0
+ line=f_Config_Backup.readline()
+ while line!="":
+ line=f_Config_Backup.readline()
+ config_nbr+=1
+ f_Config_Backup.close()
+ assert config_nbr==self.nb_conf_per_domains_in_reference_xml[index], log.F("Number of listed config for %s is not compliant with the file %s - expected : %s - found : %s"%(domain_name, self.reference_xml,self.nb_conf_per_domains_in_reference_xml[index], domains_nbr))
+ log.I("Config checking : OK")
+
+ #### END check domains and settings ####
+
+
+ @unittest.expectedFailure
+ def test_07_Import_Settings_From_Binary_Error_Case(self):
+ """
+ Testing importDomainsWithSettingsXML error case
+ ----------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - import settings from a non-compliant binary
+ - import settings from a non-existing file
+ - check Domains
+ - check Configuration
+ - check Parameters
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ - [importDomainsXML] function
+ - [importSettings] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [restoreConfiguration] function
+ - [listDomains] function
+ - [listConfiguration] function
+ - [getRules] function
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - all errors are detected, initial domains keep settings
+ """
+ log.D(self.test_07_Import_Settings_From_Binary_Error_Case.__doc__)
+
+ ### INIT Domains Settings ####
+ #Import the initial XML file
+ log.I("Import Domains with initial settings from %s"%(self.initial_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.initial_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.initial_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.initial_xml))
+ #Export a binary files from the initial setting and config
+ log.I("Export settings in the binary files %s"%(self.temp_binary))
+ out, err = self.pfw.sendCmd("exportSettings",self.temp_binary, "")
+ assert err == None, log.E("Command [exportSettings %s] : %s"%(self.temp_binary,err))
+ assert out == "Done", log.F("When using function exportSettings %s]"%(self.temp_binary))
+ #Import the reference XML file with another configuration
+ log.I("Import Domains with initial settings from %s"%(self.reference_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml))
+
+ self.pfw.sendCmd("setTuningMode", "off","")
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+ xml_path="$PFW_TEST_TOOLS/xml/XML_Test/"
+ ### END OF INIT ###
+
+ self.pfw.sendCmd("setTuningMode", "on","")
+ #Import the temporary binary file, normaly uncompatible with this config
+ self.pfw.sendCmd("setTuningMode", "on","")
+ log.I("Import settings from %s"%(self.temp_binary))
+ out, err = self.pfw.sendCmd("importSettings",self.temp_binary, "")
+ assert err == None, log.E("Command [importSettings %s] : %s"%(self.temp_binary,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(self.temp_binary))
+ log.I("Test OK : %s is not imported"%(self.temp_binary))
+ #Import setings from a non-existing binary files
+ name="Unexistent"
+ log.I("Import settings from %s"%(name))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+name, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+name,err))
+ assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+name))
+ log.I("Test OK : %s is not imported"%(name))
+ self.pfw.sendCmd("setTuningMode", "off","")
+
+ #### check domains and settings ####
+
+ #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared)
+ # Domains listing using "listDomains" command
+ log.I("Current domains listing")
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains","","")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ log.I("Command [listDomains] - correctly executed")
+ # Domains listing backup
+ f_Domains_Backup = open(self.temp_domain, "w")
+ f_Domains_Backup.write(out)
+ f_Domains_Backup.close()
+ f_Domains_Backup = open(self.temp_domain, "r")
+ domains_nbr = 0
+ line=f_Domains_Backup.readline()
+ while line!="":
+ line=f_Domains_Backup.readline()
+ domains_nbr+=1
+ f_Domains_Backup.close()
+ log.I("Actual domains number : %s" % domains_nbr)
+ assert domains_nbr==self.nb_domains_in_reference_xml, log.F("Number of listed domains is not compliant with the file %s - expected : %s - found : %s"%(self.reference_xml,self.nb_domains_in_reference_xml, domains_nbr))
+ #Check number of config per domain(2 config per domains are setup in the reference XML)
+ # Config listing
+ domain_basename="Domain_"
+ for index in range(self.nb_domains_in_reference_xml):
+ domain_name=domain_basename+str(index+1)
+ log.I("Listing config for domain %s"%(domain_name))
+ out, err = self.pfw.sendCmd("listConfigurations",domain_name,"")
+ assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err))
+ log.I("Command [listConfigurations %s] - correctly executed"%(domain_name))
+ f_Config_Backup = open(self.temp_config, "w")
+ f_Config_Backup.write(out)
+ f_Config_Backup.close()
+ f_Config_Backup = open(self.temp_config, "r")
+ config_nbr = 0
+ line=f_Config_Backup.readline()
+ while line!="":
+ line=f_Config_Backup.readline()
+ config_nbr+=1
+ f_Config_Backup.close()
+ assert config_nbr==self.nb_conf_per_domains_in_reference_xml[index], log.F("Number of listed config for %s is not compliant with the file %s - expected : %s - found : %s"%(domain_name, self.reference_xml,self.nb_conf_per_domains_in_reference_xml[index], domains_nbr))
+ log.I("Config checking : OK")
+ #Check parameter values
+ #UINT16
+ expected_value=init_value_01
+ hex_value=init_filesystem_01
+ log.I("UINT16 parameter in the conf Conf_1_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #Param_00
+ expected_value=init_value_02
+ hex_value=init_filesystem_02
+ log.I("Param_00 parameter in the conf Conf_2_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #Param_12
+ expected_value=init_value_03
+ hex_value=init_filesystem_03
+ log.I("Param_12 parameter in the conf Conf_3_1= %s"%(expected_value))
+ out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err))
+ assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out))
+ #Check parameter value on filesystem
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+ log.I("Parameters checking : OK")
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py b/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py
new file mode 100644
index 0000000..1b8013c
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_Sync.py
@@ -0,0 +1,250 @@
+# -*-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.
+
+"""
+synchronization functions testcases
+
+List of tested functions :
+--------------------------
+ - [getAutoSync] function
+ - [setAutoSync] function
+ - [sync] function
+
+Test cases :
+------------
+ - Testing getAutoSync nominal case
+ - Testing setAutoSync nominal case
+ - Testing sync nominal case
+ - Testing errors
+"""
+import commands, os
+import unittest
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+
+ def setUp(self):
+
+ pfw_filesystem=os.getenv("PFW_FILESYSTEM")
+
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.param_name_01 = "/Test/Test/TEST_DIR/BOOL"
+ self.filesystem_01 = pfw_filesystem+"/BOOL"
+ self.param_name_02 = "/Test/Test/TEST_DIR/INT16"
+ self.filesystem_02 = pfw_filesystem+"/INT16"
+ self.param_name_03 = "/Test/Test/TEST_DIR/UINT32"
+ self.filesystem_03 = pfw_filesystem+"/UINT32"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_01_getAutoSync_Case(self):
+ """
+ Testing getAutoSync nominal case
+ ----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - enable autosync
+ - get autosync state
+ - disable autosync
+ - get autosync state
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setAutoSync] function
+ - [getAutoSync] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - getAutoSync return expected state
+ """
+ log.D(self.test_01_getAutoSync_Case.__doc__)
+ value = "on"
+ log.I("Enable autosync")
+ out,err = self.pfw.sendCmd("setAutoSync", value)
+ assert err == None, log.E("When enabling autosync : %s" % (err))
+ assert out == "Done", log.F("setAutoSync - expected : Done , found : %s" % (out))
+ log.I("Check autosync state")
+ out, err = self.pfw.sendCmd("getAutoSync","")
+ assert err == None, log.E("When getting autosync state : %s" % (err))
+ assert out == value, log.F("setAutoSync - expected : %s , found : %s" % (value,out))
+ value = "off"
+ log.I("Disable autosync")
+ out,err = self.pfw.sendCmd("setAutoSync", value)
+ assert err == None, log.E("When enabling autosync : %s" % (err))
+ assert out == "Done", log.F("setAutoSync - expected : Done , found : %s" % (out))
+ log.I("Check autosync state")
+ out, err = self.pfw.sendCmd("getAutoSync","")
+ assert err == None, log.E("When getting autosync state : %s" % (err))
+ assert out == value, log.F("setAutoSync - expected : %s , found : %s" % (value,out))
+
+ def test_02_setAutoSync_Case(self):
+ """
+ Testing getAutoSync nominal case
+ -------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - enable autosync
+ - set differents parameters
+ - check the value on the filesystem
+ - disable autosync
+ - set differents parameters
+ - check the value on the filesystem
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setAutoSync] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [getAutoSync] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - When autosync is enabled, the filesystem is automatically
+ synchronized with the blackboard.
+ """
+ log.D(self.test_02_setAutoSync_Case.__doc__)
+ #Check the initial parameter value
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+ #Implement a new value
+ if int(init_value_01)==0 :
+ new_value_01 = "1"
+ else :
+ new_value_01 = "0"
+ new_value_02 = str(int(init_value_02)+1)
+ new_value_03 = str(int(init_value_03)+1)
+ #Enable the autosync
+ value = "on"
+ log.I("Enable autosync")
+ out,err = self.pfw.sendCmd("setAutoSync", value)
+ assert err == None, log.E("When enabling autosync : %s" % (err))
+ assert out == "Done", log.F("setAutoSync - expected : Done , found : %s" % (out))
+ #Set the new parameter value
+ self.pfw.sendCmd("setParameter", self.param_name_01, new_value_01)
+ self.pfw.sendCmd("setParameter", self.param_name_02, new_value_02)
+ self.pfw.sendCmd("setParameter", self.param_name_03, new_value_03)
+ #Check the filesystem values
+ #BOOL
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #INT16
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #UINT32
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+ log.I("test setAutoSync %s : OK"%(value))
+ #Enable the autosync
+ value = "off"
+ log.I("Disable autosync")
+ out,err = self.pfw.sendCmd("setAutoSync", value)
+ assert err == None, log.E("When enabling autosync : %s" % (err))
+ assert out == "Done", log.F("setAutoSync - expected : Done , found : %s" % (out))
+ #Set the new parameter value
+ self.pfw.sendCmd("setParameter", self.param_name_01, init_value_01)
+ self.pfw.sendCmd("setParameter", self.param_name_02, init_value_02)
+ self.pfw.sendCmd("setParameter", self.param_name_03, init_value_03)
+ #Check the filesystem values
+ #BOOL
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_01)
+ #INT16
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_02)
+ #UINT32
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_03)
+ log.I("test setAutoSync %s : OK"%(value))
+
+
+ @unittest.expectedFailure
+ def test_03_Manual_Sync_Case(self):
+ """
+ Testing getAutoSync nominal case
+ -------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - disable autosync
+ - set differents parameters
+ - check the value on the filesystem
+ - sync
+ - check the value on the filesystem
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [sync] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [setAutoSync] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - sync should synchronized filessystem with blackboard
+ """
+ log.D(self.test_03_Manual_Sync_Case.__doc__)
+ #Check the initial parameter value
+ init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "")
+ init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "")
+ init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "")
+ init_filesystem_01 = commands.getoutput("cat %s"%(self.filesystem_01))
+ init_filesystem_02 = commands.getoutput("cat %s"%(self.filesystem_02))
+ init_filesystem_03 = commands.getoutput("cat %s"%(self.filesystem_03))
+ #Implement a new value
+ if int(init_value_01)==0 :
+ new_value_01 = "1"
+ else :
+ new_value_01 = "0"
+ new_value_02 = str(int(init_value_02)+1)
+ new_value_03 = str(int(init_value_03)+1)
+ #Enable the autosync
+ value = "off"
+ log.I("Disable autosync")
+ out,err = self.pfw.sendCmd("setAutoSync", value)
+ assert err == None, log.E("When enabling autosync : %s" % (err))
+ assert out == "Done", log.F("setAutoSync - expected : Done , found : %s" % (out))
+ #Set the new parameter value
+ self.pfw.sendCmd("setParameter", self.param_name_01, new_value_01)
+ self.pfw.sendCmd("setParameter", self.param_name_02, new_value_02)
+ self.pfw.sendCmd("setParameter", self.param_name_03, new_value_03)
+ #Check the filesystem values, must not changed
+ #BOOL
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) == init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01)
+ #INT16
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) == init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02)
+ #UINT32
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) == init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03)
+ log.I("test setAutoSync %s : OK"%(value))
+ log.I("Sync")
+ out,err = self.pfw.sendCmd("sync", "")
+ assert err == None, log.E("When syncing : %s" % (err))
+ assert out == "Done", log.F("Sync - expected : Done , found : %s" % (out))
+ #Check the filesystem values
+ #BOOL
+ assert commands.getoutput("cat %s"%(self.filesystem_01)) != init_filesystem_01, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_01)
+ #INT16
+ assert commands.getoutput("cat %s"%(self.filesystem_02)) != init_filesystem_02, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_02)
+ #UINT32
+ assert commands.getoutput("cat %s"%(self.filesystem_03)) != init_filesystem_03, log.F("FILESYSTEM : parameter %s is updated, autosync is still enabled"%self.param_name_03)
+ log.I("test setAutoSync %s : OK"%(value))
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_getParameter.py b/test/functional-tests/PfwTestCase/Functions/tFunction_getParameter.py
new file mode 100644
index 0000000..2e02713
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_getParameter.py
@@ -0,0 +1,76 @@
+# -*-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.
+
+"""
+getParameter testcase
+
+List of tested functions :
+--------------------------
+ - [getParameter] function
+
+Test cases :
+------------
+ This function is intensively tested through all the tests of data types.
+ We test only function commands errors in that script
+"""
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.param_name = "/Test/Test/TEST_DIR/INT8"
+
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Function_Commands_Errors(self):
+ """
+ Testing importDomainsWithSettingsXML nominal case
+ -------------------------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - getParameter with a wrong parameter name
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [getParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - errors correctly detected
+ """
+ log.D(self.test_Function_Commands_Errors.__doc__)
+ #Get undefined parameter value
+ log.I("Get undefined parameter value")
+ out, err = self.pfw.sendCmd("getParameter", "Undefined_parameter")
+ print str(out)
+ assert err == None, "Error when getting parameter : %s" % (err)
+ assert out != "Done", "Error not detected when getting an undefined parameter"
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py b/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py
new file mode 100644
index 0000000..28de75d
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_listingFunctions.py
@@ -0,0 +1,597 @@
+# -*-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.
+
+"""
+All listing and dumping function testcases.
+
+List of tested functions :
+--------------------------
+ - [dumpDomains] function
+ - [dumpElement] function
+
+Test cases :
+------------
+ - Testing dumpDomains function on nominal case
+ - Testing dumpElements function on nominal case
+"""
+import commands, os
+import unittest
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+
+ def setUp(self):
+
+ self.pfw.sendCmd("setTuningMode", "on")
+
+ pfw_test_tools=os.getenv("PFW_TEST_TOOLS")
+ self.reference_dumpDomains_xml = pfw_test_tools+"/xml/XML_Test/Reference_dumpDomains.xml"
+ self.reference_dumpDomains_file = pfw_test_tools+"/xml/XML_Test/Reference_dumpDomains"
+ self.reference_dumpElement_file = pfw_test_tools+"/xml/XML_Test/Reference_dumpElement"
+ self.initial_xml = pfw_test_tools+"/xml/TestConfigurableDomains.xml"
+
+ self.list_domains=[]
+ self.list_criteria=["Crit_0", "Crit_1"]
+ self.list_parameters=[]
+ self.temp_file="tempfile"
+
+ self.domain_name = "Domain_0"
+ self.config_name = "Conf_0"
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+ if os.path.exists(self.temp_file):
+ os.remove(self.temp_file)
+
+ def test_01_dumpDomains_Case(self):
+ """
+ Testing dumpDomains function
+ ----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - import a reference XML : Reference_DumpDomains.xml
+ - dumpDomains
+ - compare out to a reference file : Reference_DumpDomains
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [dumpDomains] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to dumpDomains is the same than string in
+ the reference file
+ """
+ log.D(self.test_01_dumpDomains_Case.__doc__)
+
+ #Import a reference XML file
+ log.I("Import Domains with settings from %s"%(self.reference_dumpDomains_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_dumpDomains_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_dumpDomains_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_dumpDomains_xml))
+
+ log.I("Command [dumpDomains]")
+ out, err = self.pfw.sendCmd("dumpDomains","","")
+ assert err == None, log.E("Command [dumpDomains] : %s"%(err))
+ assert out == commands.getoutput("cat %s"%(self.reference_dumpDomains_file)), log.F("A diff is found between dumpDomains output and %s"%(self.reference_dumpDomains_file))
+ log.I("Command [dumpDomains] - correctly executed")
+
+ def test_02_dumpElements_Case(self):
+ """
+ Testing dumpElements function
+ -----------------------------
+ WARNING: This test is based on the Reference_DumpElements that must
+ be updated and reviewed when TestSubsystem.xml is modified.
+ PATH :
+ - $PFW_TEST_TOOLS/xml/XML_Tests/Reference_DumpElements
+ - $PFW_TEST_TOOLS/xml/TestSubsystem.xml
+
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - dumpElements
+ - compare out to a reference file : Reference_DumpElements
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ - [dumpElements] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [importDomainsWithSettingsXML] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to dumpElements is the same than string in
+ the reference file
+ """
+ log.D(self.test_02_dumpElements_Case.__doc__)
+
+ #Import a reference XML file
+ log.I("Import Domains with settings from %s"%(self.reference_dumpDomains_xml))
+ out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_dumpDomains_xml, "")
+ assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_dumpDomains_xml,err))
+ assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_dumpDomains_xml))
+
+ log.I("Command [dumpElement /Test/]")
+ out, err = self.pfw.sendCmd("dumpElement","/Test/")
+ assert err == None, log.E("Command [dumpElement /Test/] : %s"%(err))
+
+ f = open(self.reference_dumpElement_file, 'r')
+ ref_dumpElement = f.read()
+ f.closed
+
+ assert out == ref_dumpElement,log.F("A diff is found between dumpDomains output and %s"%(self.reference_dumpElement_file))
+ log.I("Command [dumpElement] - correctly executed")
+
+ def test_03_help_Case(self):
+ """
+ Testing help function
+ ---------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - help
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [help] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to help is not empty
+ """
+ log.D(self.test_03_help_Case.__doc__)
+ log.I("Command [help]")
+ out, err = self.pfw.sendCmd("help","")
+ assert err == None, log.E("Command [help] : %s"%(err))
+ assert out != ""
+ log.I("Command [help] - correctly executed")
+
+ def test_04_status_Case(self):
+ """
+ Testing status function
+ -----------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - status
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [status] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to status is not empty
+ """
+ log.D(self.test_04_status_Case.__doc__)
+ log.I("Command [status]")
+ out, err = self.pfw.sendCmd("status","")
+ assert err == None, log.E("Command [help] : %s"%(err))
+ assert out != ""
+ log.I("Command [status] - correctly executed")
+
+ def test_05_listCriteria_Case(self):
+ """
+ Testing listCriteria function
+ -----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listCriteria
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listCriteria] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listCriteria is not empty
+ """
+ log.D(self.test_05_listCriteria_Case.__doc__)
+ log.I("Command [listCriteria]")
+ out, err = self.pfw.sendCmd("listCriteria","")
+ assert err == None, log.E("Command [listCriteria] : %s"%(err))
+ assert out != ""
+ log.I("Command [listCriteria] - correctly executed")
+
+ def test_06_listDomains_Case(self):
+ """
+ Testing listDomains function
+ ----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listDomains
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listDomains] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listDomains is not empty
+ """
+ log.D(self.test_06_listDomains_Case.__doc__)
+ log.I("Command [listDomains]")
+ out, err = self.pfw.sendCmd("listDomains")
+ assert err == None, log.E("Command [listDomains] : %s"%(err))
+ assert out != ""
+ log.I("Command [listDomains] - correctly executed")
+
+ @unittest.expectedFailure
+ def test_06_listDomainElements_Case(self):
+ """
+ Testing listDomains function
+ ----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listDomainElements
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listDomainElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listDomains is not empty
+ """
+ log.D(self.test_06_listDomainElements_Case.__doc__)
+ log.I("Command [listDomainElements]")
+ out, err = self.pfw.sendCmd("listDomainElements",self.domain_name)
+ assert err == None, log.E("Command [listDomainElements] : %s"%(err))
+ assert out != "", log.F("Fail when listDomainElements %s: stdout is empty"%(self.domain_name))
+ log.I("Command [listDomainElements] - correctly executed")
+
+ @unittest.expectedFailure
+ def test_07_listConfigurations_Case(self):
+ """
+ Testing listConfigurations function
+ -----------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listConfigurations
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listConfigurations] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listConfigurations is not empty
+ """
+ log.D(self.test_07_listConfigurations_Case.__doc__)
+ log.I("Command [listConfigurations]")
+ out, err = self.pfw.sendCmd("listConfigurations",self.domain_name)
+ assert err == None, log.E("Command [listConfigurations] : %s"%(err))
+ assert out != "", log.F("Fail when listConfigurations %s: stdout is empty"%(self.domain_name))
+ log.I("Command [listConfigurations] - correctly executed")
+
+ def test_08_listElements_Case(self):
+ """
+ Testing listElements function
+ -----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listElements
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listElements is not empty
+ """
+ log.D(self.test_08_listElements_Case.__doc__)
+ log.I("Command [listElements]")
+ out, err = self.pfw.sendCmd("listElements")
+ assert err == None, log.E("Command [listElements] : %s"%(err))
+ out, err = self.pfw.sendCmd("listElements","/Test/")
+ assert err == None, log.E("Command [listElements /Test/] : %s"%(err))
+ assert out != ""
+ log.I("Command [listElements] - correctly executed")
+
+ def test_09_listParameters_Case(self):
+ """
+ Testing listParameters function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listParameters
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listParameters] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listParameters is not empty
+ """
+ log.D(self.test_09_listParameters_Case.__doc__)
+ log.I("Command [listParameters]")
+ out, err = self.pfw.sendCmd("listParameters")
+ assert err == None, log.E("Command [listParameters] : %s"%(err))
+ out, err = self.pfw.sendCmd("listParameters","/Test/")
+ assert err == None, log.E("Command [listParameters /Test/] : %s"%(err))
+ assert out != ""
+ log.I("Command [listParameters] - correctly executed")
+
+ def test_10_getElementSize_Case(self):
+ """
+ Testing getElementSize function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listParameters
+ - getElementSize for all parameters
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [getElementSize] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [listParameters] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to getElementSize is not empty
+ """
+ log.D(self.test_10_getElementSize_Case.__doc__)
+ log.I("Command [listParameters]")
+ out, err = self.pfw.sendCmd("listParameters","/Test/")
+ assert err == None, log.E("Command [listParameters /Test/] : %s"%(err))
+ assert out != ""
+ log.I("Command [listParameters] - correctly executed")
+ # Write out in temp file
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+
+ # Extract parameter from the temp file
+ f_temp_file = open(self.temp_file, "r")
+ lines = f_temp_file.readlines()
+ f_temp_file.close()
+
+ for line in lines :
+ if not line.find("/") == -1 :
+ final_position_in_line= line.find("[")-1
+ self.list_parameters.append(line[0:final_position_in_line])
+
+ for parameter in self.list_parameters :
+ out, err = self.pfw.sendCmd("getElementSize",parameter)
+ assert err == None, log.E("Command [getElementSize %s] : %s"%(parameter,err))
+ assert out != ""
+
+ out, err = self.pfw.sendCmd("getElementSize","/Test/")
+ assert err == None, log.E("Command [getElementSize /Test/] : %s"%(err))
+ assert out != ""
+
+ out, err = self.pfw.sendCmd("getElementSize")
+ assert err == None, log.E("Command [getElementSize /Test/] : %s"%(err))
+
+ def test_11_showProperties_Case(self):
+ """
+ Testing showProperties function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listParameters
+ - showProperties for all parameters
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [showProperties] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [listParameters] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to getElementSize is not empty
+ """
+ log.D(self.test_11_showProperties_Case.__doc__)
+ log.I("Command [listParameters]")
+ out, err = self.pfw.sendCmd("listParameters","/Test/")
+ assert err == None, log.E("Command [listParameters /Test/] : %s"%(err))
+ assert out != ""
+ log.I("Command [listParameters] - correctly executed")
+ # Write out in temp file
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+
+ # Extract parameter from the temp file
+ f_temp_file = open(self.temp_file, "r")
+ lines = f_temp_file.readlines()
+ f_temp_file.close()
+
+ for line in lines :
+ if not line.find("/") == -1 :
+ final_position_in_line= line.find("[")-1
+ self.list_parameters.append(line[0:final_position_in_line])
+
+ for parameter in self.list_parameters :
+ out, err = self.pfw.sendCmd("showProperties",parameter)
+ assert err == None, log.E("Command [showProperties %s] : %s"%(parameter,err))
+ assert out != ""
+
+ out, err = self.pfw.sendCmd("showProperties","/Test/")
+ assert err == None, log.E("Command [showProperties /Test/] : %s"%(err))
+ assert out != ""
+
+ out, err = self.pfw.sendCmd("showProperties")
+ assert err == None, log.E("Command [showProperties] : %s"%(err))
+
+ def test_12_listBelongingDomains_Case(self):
+ """
+ Testing listBelongingDomains function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listParameters
+ - listBelongingDomains for all parameters
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listBelongingDomains] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [listParameters] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listBelongingDomains is not empty
+ """
+ log.D(self.test_12_listBelongingDomains_Case.__doc__)
+ log.I("Command [listParameters]")
+ out, err = self.pfw.sendCmd("listParameters","/Test/")
+ assert err == None, log.E("Command [listParameters /Test/] : %s"%(err))
+ assert out != ""
+ log.I("Command [listParameters] - correctly executed")
+ # Write out in temp file
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+
+ # Extract parameter from the temp file
+ f_temp_file = open(self.temp_file, "r")
+ lines = f_temp_file.readlines()
+ f_temp_file.close()
+
+ for line in lines :
+ if not line.find("/") == -1 :
+ final_position_in_line= line.find("[")-1
+ self.list_parameters.append(line[0:final_position_in_line])
+
+ for parameter in self.list_parameters :
+ out, err = self.pfw.sendCmd("listBelongingDomains",parameter)
+ assert err == None, log.E("Command [listBelongingDomains %s] : %s"%(parameter,err))
+
+ out, err = self.pfw.sendCmd("listBelongingDomains","/Test/")
+ assert err == None, log.E("Command [listBelongingDomains /Test/] : %s"%(err))
+
+ out, err = self.pfw.sendCmd("listBelongingDomains")
+ assert err == None, log.E("Command [listBelongingDomains] : %s"%(err))
+
+ def test_13_listAssociatedDomains_Case(self):
+ """
+ Testing listAssociatedDomains function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listParameters
+ - listAssociatedDomains for all parameters
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listAssociatedDomains] function
+ Used commands :
+ ~~~~~~~~~~~~~~~
+ - [listParameters] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listBelongingDomains is not empty
+ """
+ log.D(self.test_13_listAssociatedDomains_Case.__doc__)
+ log.I("Command [listParameters]")
+ out, err = self.pfw.sendCmd("listParameters","/Test/")
+ assert err == None, log.E("Command [listParameters /Test/] : %s"%(err))
+ log.I("Command [listParameters] - correctly executed")
+ # Write out in temp file
+ f_temp_file = open(self.temp_file, "w")
+ f_temp_file.write(out)
+ f_temp_file.close()
+
+ # Extract parameter from the temp file
+ f_temp_file = open(self.temp_file, "r")
+ lines = f_temp_file.readlines()
+ f_temp_file.close()
+
+ for line in lines :
+ if not line.find("/") == -1 :
+ final_position_in_line= line.find("[")-1
+ self.list_parameters.append(line[0:final_position_in_line])
+
+ for parameter in self.list_parameters :
+ out, err = self.pfw.sendCmd("listAssociatedDomains",parameter)
+ assert err == None, log.E("Command [listAssociatedDomains %s] : %s"%(parameter,err))
+
+ out, err = self.pfw.sendCmd("listAssociatedDomains","/Test/")
+ assert err == None, log.E("Command [listAssociatedDomains /Test/] : %s"%(err))
+
+ def test_14_listAssociatedElements_Case(self):
+ """
+ Testing listAssociatedElements function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listAssociatedElements
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listAssociatedElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listAssociatedElements is not empty
+ """
+ log.D(self.test_14_listAssociatedElements_Case.__doc__)
+ log.I("Command [listAssociatedElements]")
+ out, err = self.pfw.sendCmd("listAssociatedElements")
+ assert err == None, log.E("Command [listAssociatedElements] : %s"%(err))
+ log.I("Command [listAssociatedElements] - correctly executed")
+
+ def test_15_listConflictingElements_Case(self):
+ """
+ Testing listConflictingElements function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listConflictingElements
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listConflictingElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listConflictingElements is not empty
+ """
+ log.D(self.test_15_listConflictingElements_Case.__doc__)
+ log.I("Command [listConflictingElements]")
+ out, err = self.pfw.sendCmd("listConflictingElements")
+ assert err == None, log.E("Command [listConflictingElements] : %s"%(err))
+ log.I("Command [listConflictingElements] - correctly executed")
+
+ def test_16_listRogueElements_Case(self):
+ """
+ Testing listRogueElements function
+ -------------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - listRogueElements
+ - check results
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [listRogueElements] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - string stdout due to listRogueElements is not empty
+ """
+ log.D(self.test_16_listRogueElements_Case.__doc__)
+ log.I("Command [listRogueElements]")
+ out, err = self.pfw.sendCmd("listRogueElements")
+ assert err == None, log.E("Command [listRogueElements] : %s"%(err))
+ log.I("Command [listRogueElements] - correctly executed")
diff --git a/test/functional-tests/PfwTestCase/Functions/tFunction_setParameter.py b/test/functional-tests/PfwTestCase/Functions/tFunction_setParameter.py
new file mode 100644
index 0000000..b5605dd
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/Functions/tFunction_setParameter.py
@@ -0,0 +1,90 @@
+# -*-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.
+
+"""
+setParameter testcase
+
+List of tested functions :
+--------------------------
+ - [setParameter] function
+
+Test cases :
+------------
+ This function is intensively tested through all the tests of data types.
+ We test only function commands errors in that script
+"""
+from Util.PfwUnitTestLib import PfwTestCase
+from Util import ACTLogging
+log=ACTLogging.Logger()
+
+class TestCases(PfwTestCase):
+ def setUp(self):
+ self.pfw.sendCmd("setTuningMode", "on")
+ self.domain_name = "Domain_0"
+ self.param_name = "/Test/Test/TEST_DIR/INT8"
+
+
+ def tearDown(self):
+ self.pfw.sendCmd("setTuningMode", "off")
+
+ def test_Function_Commands_Errors(self):
+ """
+ Testing function command errors
+ ----------------------------
+ Test case description :
+ ~~~~~~~~~~~~~~~~~~~~~~~
+ - setParameter with a wrong parameter name
+ - setParameter with a forbiden character value
+ - setParameter with a Float into an Integer parameter
+ Tested commands :
+ ~~~~~~~~~~~~~~~~~
+ - [setParameter] function
+ Expected result :
+ ~~~~~~~~~~~~~~~~~
+ - errors correctly detected
+ """
+ log.D(self.test_Function_Commands_Errors.__doc__)
+ #Set undefined parameter value
+ log.I("Set undefined parameter value")
+ out, err = self.pfw.sendCmd("setParameter", "Undefined_parameter", "0")
+ assert err == None, "Error when setting parameter : %s" % (err)
+ assert out != "Done", "Error not detected when setting an undefined parameter"
+ #Set parameter with a forbiden character value
+ log.I("Set parameter with a forbiden character value")
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, "Wrong_Value")
+ assert err == None, "Error when setting parameter : %s" % (err)
+ assert out != "Done", "Error not detected when setting a parameter with a forbiden character value"
+ log.I("Errors correctly detected")
+ #Set parameter with a Float into an Integer parameter
+ log.I("Set parameter with a Float into an Integer parameter")
+ out, err = self.pfw.sendCmd("setParameter", self.param_name, "1.2345")
+ assert err == None, "Error when setting parameter : %s" % (err)
+ assert out != "Done", "Error not detected when setting a Float into an Integer parameter"
+ log.I("Errors correctly detected")
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")
diff --git a/test/functional-tests/PfwTestCase/__init__.py b/test/functional-tests/PfwTestCase/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/functional-tests/PfwTestCase/__init__.py
diff --git a/test/functional-tests/Util/ACTLogging.py b/test/functional-tests/Util/ACTLogging.py
new file mode 100644
index 0000000..fdc71ef
--- /dev/null
+++ b/test/functional-tests/Util/ACTLogging.py
@@ -0,0 +1,48 @@
+# -*-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.
+
+class Logger(object) :
+ def E(self, string):
+ print "\nERROR: %s\n" % (string)
+ return "ERROR: %s" % (string)
+
+ def F(self, string):
+ print "\nFAIL : %s\n" % (string)
+ return "FAIL : %s" % (string)
+
+ def I(self, string):
+ print "INFO : %s" % (string)
+ return "INFO : %s" % (string)
+
+ def D(self, string):
+ print "\n======================================================================"
+ print "%s" %(string)
+ print "======================================================================"
+ return string
diff --git a/test/functional-tests/Util/PfwUnitTestLib.py b/test/functional-tests/Util/PfwUnitTestLib.py
new file mode 100644
index 0000000..d9c2f8c
--- /dev/null
+++ b/test/functional-tests/Util/PfwUnitTestLib.py
@@ -0,0 +1,110 @@
+# -*-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 subprocess
+import unittest
+import time
+
+class RemoteCli(object):
+ def sendCmd(self, cmd, *args):
+ shell_cmd = " ".join([self.platform_command, cmd])
+ if args is not None:
+ shell_cmd += " " + " ".join(args)
+ print "CMD :",
+ print "[" + shell_cmd + "]"
+ try:
+ p = subprocess.Popen(shell_cmd, shell=True, stdout=subprocess.PIPE)
+ except Exception as (errno, strerror):
+ return None, strerror
+ out, err = p.communicate()
+ if out is not None:
+ out = out.strip()
+ return out, err
+
+class Pfw(RemoteCli):
+ def __init__(self):
+ self.platform_command = "remote-process localhost 5000 "
+
+class Hal(RemoteCli):
+ def __init__(self):
+ self.platform_command = "remote-process localhost 5001 "
+
+ # Starts the HAL exe
+ def startHal(self):
+ cmd= "test-platform $PFW_TEST_CONFIGURATION"
+ subprocess.Popen(cmd, shell=True)
+ pass
+
+ # Send command "stop" to the HAL
+ def stopHal(self):
+ subprocess.call("remote-process localhost 5001 exit", shell=True)
+
+ def createInclusiveCriterion(self, name, nb):
+ self.sendCmd("createInclusiveSelectionCriterion", name, nb)
+
+ def createExclusiveCriterion(self, name, nb):
+ self.sendCmd("createExclusiveSelectionCriterion", name, nb)
+
+ # Starts the Pfw
+ def start(self):
+ self.sendCmd("start")
+
+# A PfwTestCase gather tests performed on one instance of the PFW.
+class PfwTestCase(unittest.TestCase):
+
+ hal = Hal()
+
+ def __init__(self, argv):
+ super(PfwTestCase, self).__init__(argv)
+ self.pfw = Pfw()
+
+ @classmethod
+ def setUpClass(cls):
+ cls.startHal()
+
+ @classmethod
+ def tearDownClass(cls):
+ cls.stopHal()
+
+ @classmethod
+ def startHal(cls):
+ # set up the Hal & pfw
+ cls.hal.startHal()
+ time.sleep(0.1)
+ # create criterions
+ cls.hal.createInclusiveCriterion("Crit_0", "2")
+ cls.hal.createExclusiveCriterion("Crit_1", "2")
+ # start the Pfw
+ cls.hal.start()
+
+ @classmethod
+ def stopHal(cls):
+ cls.hal.stopHal()
+ time.sleep(0.1)
diff --git a/test/functional-tests/Util/__init__.py b/test/functional-tests/Util/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/functional-tests/Util/__init__.py
diff --git a/test/functional-tests/xml/TestConfigurableDomains.xml b/test/functional-tests/xml/TestConfigurableDomains.xml
new file mode 100644
index 0000000..fdc77e1
--- /dev/null
+++ b/test/functional-tests/xml/TestConfigurableDomains.xml
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="/home/lab/ICS/hardware/intel/PRIVATE/parameter-framework/test/configuration/Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_0">
+ <Configurations>
+ <Configuration Name="Conf_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES" />
+ </ConfigurableElements>
+
+ <Settings>
+ <Configuration Name="Conf_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES">
+ <Component Name="TEST_TYPES">
+ <EnumParameter Name="ENUM">ENUM_NOMINAL</EnumParameter>
+ <BitParameterBlock Name="BLOCK_8BIT">
+ <BitParameter Name="BIT_0_3">0</BitParameter>
+ <BitParameter Name="BIT_3_1">0</BitParameter>
+ <BitParameter Name="BIT_4_1">0</BitParameter>
+ <BitParameter Name="BIT_6_2">0</BitParameter>
+ <BitParameter Name="BIT_7_1">0</BitParameter>
+ </BitParameterBlock>
+ <ParameterBlock Name="BLOCK_PARAMETER">
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ </ParameterBlock>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES">
+ <Component Name="TEST_TYPES">
+ <!--Tested Enum-->
+ <EnumParameter Name="ENUM">ENUM_MIN</EnumParameter>
+ <!--Tested Bit parameter block-->
+ <BitParameterBlock Name="BLOCK_8BIT">
+ <BitParameter Name="BIT_0_3">0</BitParameter>
+ <BitParameter Name="BIT_3_1">0</BitParameter>
+ <BitParameter Name="BIT_4_1">0</BitParameter>
+ <BitParameter Name="BIT_6_2">0</BitParameter>
+ <BitParameter Name="BIT_7_1">0</BitParameter>
+ </BitParameterBlock>
+ <ParameterBlock Name="BLOCK_PARAMETER">
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ </ParameterBlock>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Reference_Compliant.xml b/test/functional-tests/xml/XML_Test/Reference_Compliant.xml
new file mode 100644
index 0000000..48b1720
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_Compliant.xml
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="/home/lab/ICS/hardware/intel/PRIVATE/parameter-framework/test/configuration/Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">2.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.2</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">1.2</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.2</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">1.2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">1.2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">1.2</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+
+ <ConfigurableDomain Name="Domain_2">
+ <Configurations>
+ <Configuration Name="Conf_2_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_2_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_2_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00">4</IntegerParameter>
+ <IntegerParameter Name="Param_01">4</IntegerParameter>
+ <IntegerParameter Name="Param_02">4</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_2_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00">5</IntegerParameter>
+ <IntegerParameter Name="Param_01">5</IntegerParameter>
+ <IntegerParameter Name="Param_02">5</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+
+ <ConfigurableDomain Name="Domain_3">
+ <Configurations>
+ <Configuration Name="Conf_3_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_3_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_3_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">4</IntegerParameter>
+ <IntegerParameter Name="Param_11">4</IntegerParameter>
+ <IntegerParameter Name="Param_12">4</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_3_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">5</IntegerParameter>
+ <IntegerParameter Name="Param_11">5</IntegerParameter>
+ <IntegerParameter Name="Param_12">5</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Reference_Criteria.xml b/test/functional-tests/xml/XML_Test/Reference_Criteria.xml
new file mode 100644
index 0000000..76664e2
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_Criteria.xml
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Excludes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.9</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+
+ <ConfigurableDomain Name="Domain_2">
+ <Configurations>
+ <Configuration Name="Conf_2_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_2_1">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_2_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00">4</IntegerParameter>
+ <IntegerParameter Name="Param_01">4</IntegerParameter>
+ <IntegerParameter Name="Param_02">4</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_2_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00">5</IntegerParameter>
+ <IntegerParameter Name="Param_01">5</IntegerParameter>
+ <IntegerParameter Name="Param_02">5</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+
+ <ConfigurableDomain Name="Domain_3">
+ <Configurations>
+ <Configuration Name="Conf_3_0">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_0"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_3_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_3_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">4</IntegerParameter>
+ <IntegerParameter Name="Param_11">4</IntegerParameter>
+ <IntegerParameter Name="Param_12">4</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_3_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">5</IntegerParameter>
+ <IntegerParameter Name="Param_11">5</IntegerParameter>
+ <IntegerParameter Name="Param_12">5</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Reference_Split_Domain.xml b/test/functional-tests/xml/XML_Test/Reference_Split_Domain.xml
new file mode 100644
index 0000000..7f7edbc
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_Split_Domain.xml
@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--DOMAIN 1 DEFINITION-->
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Excludes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_MAIN" />
+ <!--ConfigurableElement Path="/Test/Test/TEST_MAIN/TEST_DIR_0" />
+ <ConfigurableElement Path="/Test/Test/TEST_MAIN/TEST_DIR_1" />
+ <ConfigurableElement Path="/Test/Test/TEST_MAIN/TEST_DIR_2" /-->
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_MAIN">
+ <Component Name="TEST_MAIN">
+ <Component Name="TEST_DIR_0">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">2.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ <Component Name="TEST_DIR_1">
+ <IntegerParameter Name="Param_00">4</IntegerParameter>
+ <IntegerParameter Name="Param_01">4</IntegerParameter>
+ <IntegerParameter Name="Param_02">4</IntegerParameter>
+ </Component>
+ <Component Name="TEST_DIR_2">
+ <IntegerParameter Name="Param_10">4</IntegerParameter>
+ <IntegerParameter Name="Param_11">4</IntegerParameter>
+ <IntegerParameter Name="Param_12">4</IntegerParameter>
+ </Component>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_MAIN">
+ <Component Name="TEST_MAIN">
+ <Component Name="TEST_DIR_0">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">2</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">2.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">2.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ <Component Name="TEST_DIR_1">
+ <IntegerParameter Name="Param_00">5</IntegerParameter>
+ <IntegerParameter Name="Param_01">5</IntegerParameter>
+ <IntegerParameter Name="Param_02">5</IntegerParameter>
+ </Component>
+ <Component Name="TEST_DIR_2">
+ <IntegerParameter Name="Param_10">5</IntegerParameter>
+ <IntegerParameter Name="Param_11">5</IntegerParameter>
+ <IntegerParameter Name="Param_12">5</IntegerParameter>
+ </Component>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+<!--DOMAIN 2 DEFINITION-->
+ <ConfigurableDomain Name="Domain_2">
+ <Configurations>
+ <Configuration Name="Conf_2_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_2_1">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements/>
+ </ConfigurableDomain>
+<!--DOMAIN 3 DEFINITION-->
+ <ConfigurableDomain Name="Domain_3">
+ <Configurations>
+ <Configuration Name="Conf_3_0">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_0"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_3_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements/>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Reference_dumpDomains b/test/functional-tests/xml/XML_Test/Reference_dumpDomains
new file mode 100644
index 0000000..9277d20
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_dumpDomains
@@ -0,0 +1,12 @@
+- ConfigurableDomains: Test
+ - ConfigurableDomain: Domain_0_1 = {Sequence aware: no, Last applied configuration: <none>}
+ - Configuration: Conf_0_0
+ - ConfigurableDomain: Domain_1_2 = {Sequence aware: no, Last applied configuration: <none>}
+ - Configuration: Conf_1_0
+ - CompoundRule = All
+ - SelectionCriterionRule = Crit_0 Includes State_0x1
+ - SelectionCriterionRule = Crit_1 Is State_1
+ - Configuration: Conf_1_1
+ - CompoundRule = Any
+ - SelectionCriterionRule = Crit_0 Includes State_0x2
+ - SelectionCriterionRule = Crit_1 IsNot State_1
diff --git a/test/functional-tests/xml/XML_Test/Reference_dumpDomains.xml b/test/functional-tests/xml/XML_Test/Reference_dumpDomains.xml
new file mode 100644
index 0000000..844099e
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_dumpDomains.xml
@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="/home/lab/ICS/hardware/intel/PRIVATE/parameter-framework/test/configuration/Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+
+ <ConfigurableDomain Name="Domain_0_1">
+ <Configurations>
+ <Configuration Name="Conf_0_0"/>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_0_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00">0</IntegerParameter>
+ <IntegerParameter Name="Param_01">0</IntegerParameter>
+ <IntegerParameter Name="Param_02">0</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+ <ConfigurableDomain Name="Domain_1_2">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">4</IntegerParameter>
+ <IntegerParameter Name="Param_11">4</IntegerParameter>
+ <IntegerParameter Name="Param_12">4</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_1">
+ <Component Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10">5</IntegerParameter>
+ <IntegerParameter Name="Param_11">5</IntegerParameter>
+ <IntegerParameter Name="Param_12">5</IntegerParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Reference_dumpElement b/test/functional-tests/xml/XML_Test/Reference_dumpElement
new file mode 100644
index 0000000..37342fa
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Reference_dumpElement
@@ -0,0 +1,89 @@
+- SystemClass: Test
+ - Subsystem: Test
+ - Component: TEST_DIR
+ - BooleanParameter: BOOL = 1
+ - FixedPointParameter: FP8_Q0.7 = 0.8984375
+ - FixedPointParameter: FP8_Q7.0 = 1
+ - FixedPointParameter: FP8_Q3.4 = 1.0000
+ - FixedPointParameter: FP16_Q0.15 = 0.899993896484375
+ - FixedPointParameter: FP16_Q15.0 = 1
+ - FixedPointParameter: FP16_Q7.8 = 1.00000000
+ - FixedPointParameter: FP32_Q0.31 = 0.8999999999068677425384521484375
+ - FixedPointParameter: FP32_Q31.0 = 1
+ - FixedPointParameter: FP32_Q15.16 = 1.0000000000000000
+ - FixedPointParameter: FP32_Q8.20 = 1.00000000000000000000
+ - IntegerParameter: UINT32 = 1
+ - IntegerParameter: INT32 = 1
+ - IntegerParameter: UINT32_Max = 1
+ - IntegerParameter: INT32_Max = 1
+ - IntegerParameter: UINT16 = 1
+ - IntegerParameter: INT16 = 1
+ - IntegerParameter: UINT16_Max = 1
+ - IntegerParameter: INT16_Max = 1
+ - IntegerParameter: UINT8 = 1
+ - IntegerParameter: INT8 = 1
+ - IntegerParameter: UINT8_Max = 1
+ - IntegerParameter: INT8_Max = 1
+ - IntegerParameter: UINT32_ARRAY = 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ - IntegerParameter: INT16_ARRAY = 1 0 0 0 0
+ - IntegerParameter: UINT8_ARRAY = 1 0 0 0 0
+ - IntegerParameter: UINT8_Max_ARRAY = 1 0 0 0 0
+ - StringParameter: STR_CHAR128 = string_Conf_1
+ - Component: TEST_DOMAIN_0
+ - IntegerParameter: Param_00 = 4
+ - IntegerParameter: Param_01 = 4
+ - IntegerParameter: Param_02 = 4
+ - Component: TEST_DOMAIN_1
+ - IntegerParameter: Param_10 = 4
+ - IntegerParameter: Param_11 = 4
+ - IntegerParameter: Param_12 = 4
+ - Component: TEST_TYPES
+ - EnumParameter: ENUM = ENUM_MIN
+ - BitParameterBlock: BLOCK_8BIT
+ - BitParameter: BIT_0_3 = 0
+ - BitParameter: BIT_3_1 = 0
+ - BitParameter: BIT_4_1 = 0
+ - BitParameter: BIT_6_2 = 0
+ - BitParameter: BIT_7_1 = 0
+ - ParameterBlock: BLOCK_PARAMETER
+ - IntegerParameter: UINT8 = 0
+ - IntegerParameter: UINT16 = 0
+ - IntegerParameter: UINT32 = 0
+ - Component: TEST_MAIN
+ - Component: TEST_DIR_0
+ - BooleanParameter: BOOL = 0
+ - FixedPointParameter: FP8_Q0.7 = 0.1015625
+ - FixedPointParameter: FP8_Q7.0 = 2
+ - FixedPointParameter: FP8_Q3.4 = 2.1250
+ - FixedPointParameter: FP16_Q0.15 = 0.100006103515625
+ - FixedPointParameter: FP16_Q15.0 = 2
+ - FixedPointParameter: FP16_Q7.8 = 2.00000000
+ - FixedPointParameter: FP32_Q0.31 = 0.1000000000931322574615478515625
+ - FixedPointParameter: FP32_Q31.0 = 2
+ - FixedPointParameter: FP32_Q15.16 = 2.1000061035156250
+ - FixedPointParameter: FP32_Q8.20 = 2.10000038146972656250
+ - IntegerParameter: UINT32 = 0
+ - IntegerParameter: INT32 = 0
+ - IntegerParameter: UINT32_Max = 0
+ - IntegerParameter: INT32_Max = 0
+ - IntegerParameter: UINT16 = 0
+ - IntegerParameter: INT16 = 0
+ - IntegerParameter: UINT16_Max = 0
+ - IntegerParameter: INT16_Max = 0
+ - IntegerParameter: UINT8 = 0
+ - IntegerParameter: INT8 = 0
+ - IntegerParameter: UINT8_Max = 0
+ - IntegerParameter: INT8_Max = 0
+ - IntegerParameter: UINT32_ARRAY = 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+ - IntegerParameter: INT16_ARRAY = 0 0 0 0 0
+ - IntegerParameter: UINT8_ARRAY = 0 0 0 0 0
+ - IntegerParameter: UINT8_Max_ARRAY = 0 0 0 0 0
+ - StringParameter: STR_CHAR128 = string_Conf_1_1
+ - Component: TEST_DIR_1
+ - IntegerParameter: Param_00 = 4
+ - IntegerParameter: Param_01 = 4
+ - IntegerParameter: Param_02 = 4
+ - Component: TEST_DIR_2
+ - IntegerParameter: Param_10 = 4
+ - IntegerParameter: Param_11 = 4
+ - IntegerParameter: Param_12 = 4 \ No newline at end of file
diff --git a/test/functional-tests/xml/XML_Test/Uncompliant_OutboundParameter.xml b/test/functional-tests/xml/XML_Test/Uncompliant_OutboundParameter.xml
new file mode 100644
index 0000000..339a75c
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Uncompliant_OutboundParameter.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">2</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.9</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredConfigurableElement.xml b/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredConfigurableElement.xml
new file mode 100644
index 0000000..f8c00be
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredConfigurableElement.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/ERROR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/ERROR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.9</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredParameter.xml b/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredParameter.xml
new file mode 100644
index 0000000..f831de5
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Uncompliant_UndeclaredParameter.xml
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <BooleanParameter Name="UNDECLARED">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <BooleanParameter Name="UNDECLARED">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.9</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/XML_Test/Uncompliant_UnorderConfigurableElement.xml b/test/functional-tests/xml/XML_Test/Uncompliant_UnorderConfigurableElement.xml
new file mode 100644
index 0000000..3d9aaa4
--- /dev/null
+++ b/test/functional-tests/xml/XML_Test/Uncompliant_UnorderConfigurableElement.xml
@@ -0,0 +1,102 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_1">
+ <Configurations>
+ <Configuration Name="Conf_1_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ </ConfigurableElements>
+ <Settings>
+ <Configuration Name="Conf_1_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DOMAIN_0">
+ <Component Name="TEST_DOMAIN_0">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0.9</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">-1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">-1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">-1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">-1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/configuration/ParameterFrameworkConfiguration.xml b/test/functional-tests/xml/configuration/ParameterFrameworkConfiguration.xml
new file mode 100644
index 0000000..85e9a0a
--- /dev/null
+++ b/test/functional-tests/xml/configuration/ParameterFrameworkConfiguration.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ParameterFrameworkConfiguration SystemClassName="Test" ServerPort="5000" TuningAllowed="true">
+ <SubsystemPlugins>
+ <Location Folder="">
+ <Plugin Name="libtest-subsystem.so"/>
+ </Location>
+ </SubsystemPlugins>
+ <StructureDescriptionFileLocation Path="Structure/Test/TestClass.xml"/>
+ <SettingsConfiguration>
+ <ConfigurableDomainsFileLocation Path="Settings/Test/TestConfigurableDomains.xml"/>
+ </SettingsConfiguration>
+</ParameterFrameworkConfiguration>
diff --git a/test/functional-tests/xml/configuration/Settings/Test/TestConfigurableDomains.xml b/test/functional-tests/xml/configuration/Settings/Test/TestConfigurableDomains.xml
new file mode 100644
index 0000000..fdc77e1
--- /dev/null
+++ b/test/functional-tests/xml/configuration/Settings/Test/TestConfigurableDomains.xml
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ConfigurableDomains xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="/home/lab/ICS/hardware/intel/PRIVATE/parameter-framework/test/configuration/Schemas/ConfigurableDomains.xsd" SystemClassName="Test">
+ <ConfigurableDomain Name="Domain_0">
+ <Configurations>
+ <Configuration Name="Conf_0">
+ <CompoundRule Type="All">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x1"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="Is" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ <Configuration Name="Conf_1">
+ <CompoundRule Type="Any">
+ <SelectionCriterionRule SelectionCriterion="Crit_0" MatchesWhen="Includes" Value="State_0x2"/>
+ <SelectionCriterionRule SelectionCriterion="Crit_1" MatchesWhen="IsNot" Value="State_1"/>
+ </CompoundRule>
+ </Configuration>
+ </Configurations>
+
+ <ConfigurableElements>
+ <ConfigurableElement Path="/Test/Test/TEST_DIR" />
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES" />
+ </ConfigurableElements>
+
+ <Settings>
+ <Configuration Name="Conf_0">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">0</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">0</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">0</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ <IntegerParameter Name="INT32">0</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="INT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">0</IntegerParameter>
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="INT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">0</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">0</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">0</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">0</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_0</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES">
+ <Component Name="TEST_TYPES">
+ <EnumParameter Name="ENUM">ENUM_NOMINAL</EnumParameter>
+ <BitParameterBlock Name="BLOCK_8BIT">
+ <BitParameter Name="BIT_0_3">0</BitParameter>
+ <BitParameter Name="BIT_3_1">0</BitParameter>
+ <BitParameter Name="BIT_4_1">0</BitParameter>
+ <BitParameter Name="BIT_6_2">0</BitParameter>
+ <BitParameter Name="BIT_7_1">0</BitParameter>
+ </BitParameterBlock>
+ <ParameterBlock Name="BLOCK_PARAMETER">
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ </ParameterBlock>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ <Configuration Name="Conf_1">
+ <ConfigurableElement Path="/Test/Test/TEST_DIR">
+ <Component Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL">1</BooleanParameter>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q7.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP8_Q3.4">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q0.15">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q15.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP16_Q7.8">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q0.31">0.9</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q31.0">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q15.16">1</FixedPointParameter>
+ <FixedPointParameter Name="FP32_Q8.20">1</FixedPointParameter>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32">1</IntegerParameter>
+ <IntegerParameter Name="INT32">1</IntegerParameter>
+ <IntegerParameter Name="UINT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT32_Max">1</IntegerParameter>
+ <IntegerParameter Name="UINT16">1</IntegerParameter>
+ <IntegerParameter Name="INT16">1</IntegerParameter>
+ <IntegerParameter Name="UINT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT16_Max">1</IntegerParameter>
+ <IntegerParameter Name="UINT8">1</IntegerParameter>
+ <IntegerParameter Name="INT8">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max">1</IntegerParameter>
+ <IntegerParameter Name="INT8_Max">1</IntegerParameter>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="INT16_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_ARRAY">1</IntegerParameter>
+ <IntegerParameter Name="UINT8_Max_ARRAY">1</IntegerParameter>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128">string_Conf_1</StringParameter>
+ </Component>
+ </ConfigurableElement>
+ <ConfigurableElement Path="/Test/Test/TEST_TYPES">
+ <Component Name="TEST_TYPES">
+ <!--Tested Enum-->
+ <EnumParameter Name="ENUM">ENUM_MIN</EnumParameter>
+ <!--Tested Bit parameter block-->
+ <BitParameterBlock Name="BLOCK_8BIT">
+ <BitParameter Name="BIT_0_3">0</BitParameter>
+ <BitParameter Name="BIT_3_1">0</BitParameter>
+ <BitParameter Name="BIT_4_1">0</BitParameter>
+ <BitParameter Name="BIT_6_2">0</BitParameter>
+ <BitParameter Name="BIT_7_1">0</BitParameter>
+ </BitParameterBlock>
+ <ParameterBlock Name="BLOCK_PARAMETER">
+ <IntegerParameter Name="UINT8">0</IntegerParameter>
+ <IntegerParameter Name="UINT16">0</IntegerParameter>
+ <IntegerParameter Name="UINT32">0</IntegerParameter>
+ </ParameterBlock>
+ </Component>
+ </ConfigurableElement>
+ </Configuration>
+ </Settings>
+ </ConfigurableDomain>
+</ConfigurableDomains>
diff --git a/test/functional-tests/xml/configuration/Structure/Test/TestClass.xml b/test/functional-tests/xml/configuration/Structure/Test/TestClass.xml
new file mode 100644
index 0000000..480aa05
--- /dev/null
+++ b/test/functional-tests/xml/configuration/Structure/Test/TestClass.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<SystemClass Name="Test">
+ <SubsystemInclude Path="TestSubsystem.xml"/>
+</SystemClass>
diff --git a/test/functional-tests/xml/configuration/Structure/Test/TestSubsystem.xml b/test/functional-tests/xml/configuration/Structure/Test/TestSubsystem.xml
new file mode 100644
index 0000000..839b418
--- /dev/null
+++ b/test/functional-tests/xml/configuration/Structure/Test/TestSubsystem.xml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Subsystem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="/home/lab/ICS/hardware/intel/PRIVATE/parameter-framework/test/configuration/Schemas/Subsystem.xsd" Name="Test" Type="TEST" Endianness="Little">
+ <ComponentLibrary>
+ <ComponentType Name="TEST_DIR">
+ <!-- Tested Booleans -->
+ <BooleanParameter Name="BOOL" Mapping="Binary:BOOL"/>
+ <!-- Tested FixedPoints -->
+ <FixedPointParameter Name="FP8_Q0.7" Size="8" Integral="0" Fractional="7" Mapping="Binary:FP8_Q.7"/>
+ <FixedPointParameter Name="FP8_Q7.0" Size="8" Integral="7" Fractional="0" Mapping="Binary:FP8_7.0"/>
+ <FixedPointParameter Name="FP8_Q3.4" Size="8" Integral="3" Fractional="4" Mapping="Binary:FP8_3.4"/>
+ <FixedPointParameter Name="FP16_Q0.15" Size="16" Integral="0" Fractional="15" Mapping="Binary:FP16_Q.15"/>
+ <FixedPointParameter Name="FP16_Q15.0" Size="16" Integral="15" Fractional="0" Mapping="Binary:FP16_15.0"/>
+ <FixedPointParameter Name="FP16_Q7.8" Size="16" Integral="7" Fractional="8" Mapping="Binary:FP16_7.8"/>
+ <FixedPointParameter Name="FP32_Q0.31" Size="32" Integral="0" Fractional="31" Mapping="Binary:FP32_Q.31"/>
+ <FixedPointParameter Name="FP32_Q31.0" Size="32" Integral="31" Fractional="0" Mapping="Binary:FP32_31.0"/>
+ <FixedPointParameter Name="FP32_Q15.16" Size="32" Integral="15" Fractional="16" Mapping="Binary:FP32_15.16"/>
+ <FixedPointParameter Name="FP32_Q8.20" Size="32" Integral="8" Fractional="20" Mapping="Binary:FP32_Q8.20"/>
+ <!-- Tested Integers -->
+ <IntegerParameter Name="UINT32" Size="32" Signed="false" Max="1000" Mapping="Binary:UINT32"/>
+ <IntegerParameter Name="INT32" Size="32" Signed="true" Min="-1000" Max="1000" Mapping="Binary:INT32"/>
+ <IntegerParameter Name="UINT32_Max" Size="32" Signed="false" Max="4294967295" Mapping="Binary:UINT32_Max"/>
+ <IntegerParameter Name="INT32_Max" Size="32" Signed="true" Min="-2147483648" Max="2147483647" Mapping="Binary:INT32"/>
+ <IntegerParameter Name="UINT16" Size="16" Signed="false" Max="1000" Mapping="Binary:UINT16"/>
+ <IntegerParameter Name="INT16" Size="16" Signed="true" Min="-1000" Max="1000" Mapping="Binary:INT16"/>
+ <IntegerParameter Name="UINT16_Max" Size="16" Signed="false" Max="65535" Mapping="Binary:UINT16_Max"/>
+ <IntegerParameter Name="INT16_Max" Size="16" Signed="true" Min="-32768" Max="32767" Mapping="Binary:INT16_Max"/>
+ <IntegerParameter Name="UINT8" Size="8" Signed="false" Max="100" Mapping="Binary:UINT8"/>
+ <IntegerParameter Name="INT8" Size="8" Signed="true" Min="-100" Max="100" Mapping="Binary:INT8"/>
+ <IntegerParameter Name="UINT8_Max" Size="8" Signed="false" Max="255" Mapping="Binary:UINT8_Max"/>
+ <IntegerParameter Name="INT8_Max" Size="8" Signed="true" Min="-128" Max="127" Mapping="Binary:INT8_Max"/>
+ <!-- Tested Arrays -->
+ <IntegerParameter Name="UINT32_ARRAY" Size="32" Signed="false" ArrayLength="100" Min="0" Max="100" Mapping="Binary:UINT32_ARRAY"/>
+ <IntegerParameter Name="INT16_ARRAY" Size="16" Signed="true" ArrayLength="5" Min="-50" Max="50" Mapping="Binary:INT16_ARRAY_signed"/>
+ <IntegerParameter Name="UINT8_ARRAY" Size="8" Signed="false" ArrayLength="5" Min="0" Max="15" Mapping="Binary:UINT8_ARRAY"/>
+ <IntegerParameter Name="UINT8_Max_ARRAY" Size="8" Signed="false" ArrayLength="5" Min="0" Max="255" Mapping="Binary:UINT8_Max_ARRAY"/>
+ <!-- Tested String-->
+ <StringParameter Name="STR_CHAR128" MaxLength="128" Mapping="String:STRING"/>
+ </ComponentType>
+ <ComponentType Name="TEST_DOMAIN_0">
+ <IntegerParameter Name="Param_00" Size="16" Signed="false" Mapping="Binary:Param_00"/>
+ <IntegerParameter Name="Param_01" Size="16" Signed="false" Mapping="Binary:Param_01"/>
+ <IntegerParameter Name="Param_02" Size="16" Signed="false" Mapping="Binary:Param_02"/>
+ </ComponentType>
+ <ComponentType Name="TEST_DOMAIN_1">
+ <IntegerParameter Name="Param_10" Size="16" Signed="false" Mapping="Binary:Param_10"/>
+ <IntegerParameter Name="Param_11" Size="16" Signed="false" Mapping="Binary:Param_11"/>
+ <IntegerParameter Name="Param_12" Size="16" Signed="false" Mapping="Binary:Param_12"/>
+ </ComponentType>
+ <ComponentType Name="TEST_TYPES">
+ <!-- Tested Enum -->
+ <EnumParameter Name="ENUM" Size="8" Mapping="Binary:ENUM">
+ <ValuePair Literal="ENUM_MIN" Numerical="-128"/>
+ <ValuePair Literal="ENUM_MAX" Numerical="127"/>
+ <ValuePair Literal="ENUM_NOMINAL" Numerical="5"/>
+ <ValuePair Literal="ENUM_OOB" Numerical="255"/>
+ <ValuePair Literal="ENUM_OOS" Numerical="256"/>
+ </EnumParameter>
+ <BitParameterBlock Name="BLOCK_8BIT" Size="8" Mapping="Binary:BLOCK_8BIT">
+ <BitParameter Name="BIT_0_3" Size="3" Pos="0"/>
+ <BitParameter Name="BIT_3_1" Size="1" Pos="3"/>
+ <BitParameter Name="BIT_4_1" Size="1" Pos="4"/>
+ <BitParameter Name="BIT_6_2" Size="2" Pos="6"/>
+ <BitParameter Name="BIT_7_1" Size="1" Pos="7"/>
+ </BitParameterBlock>
+ <ParameterBlock Name="BLOCK_PARAMETER">
+ <IntegerParameter Name="UINT8" Size="8" Signed="false" Mapping="Binary:BLOCK_UINT8"/>
+ <IntegerParameter Name="UINT16" Size="16" Signed="false" Mapping="Binary:BLOCK_UINT16"/>
+ <IntegerParameter Name="UINT32" Size="32" Signed="false" Mapping="Binary:BLOCK_UINT32"/>
+ </ParameterBlock>
+ </ComponentType>
+ <ComponentType Name="TEST_MAIN">
+ <Component Name = "TEST_DIR_0" Type="TEST_DIR"/>
+ <Component Name = "TEST_DIR_1" Type="TEST_DOMAIN_0"/>
+ <Component Name = "TEST_DIR_2" Type="TEST_DOMAIN_1"/>
+ </ComponentType>
+ </ComponentLibrary>
+ <InstanceDefinition>
+ <Component Name="TEST_DIR" Type="TEST_DIR" Mapping="Directory:/tmp/test-parameters"/>
+ <Component Name="TEST_DOMAIN_0" Type="TEST_DOMAIN_0" Mapping="Directory:/tmp/test-parameters"/>
+ <Component Name="TEST_DOMAIN_1" Type="TEST_DOMAIN_1" Mapping="Directory:/tmp/test-parameters"/>
+ <Component Name="TEST_TYPES" Type="TEST_TYPES" Mapping="Directory:/tmp/test-parameters"/>
+ <Component Name="TEST_MAIN" Type="TEST_MAIN" Mapping="Directory:/tmp/test-parameters"/>
+ </InstanceDefinition>
+</Subsystem>