| # -*-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 |
| |
| Test cases : |
| ------------ |
| - Testing importDomainsWithSettingsXML nominal case |
| - Testing exportDomainsWithSettingsXML nominal case |
| - Testing exportDomainsXML/importDomainsXML 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 = os.environ["PFW_RESULT"] + "/UINT16" |
| self.param_name_02 = "/Test/Test/TEST_DOMAIN_0/Param_00" |
| self.filesystem_02 = os.environ["PFW_RESULT"] + "/Param_00" |
| self.param_name_03 = "/Test/Test/TEST_DOMAIN_1/Param_12" |
| self.filesystem_03 = os.environ["PFW_RESULT"] + "/Param_12" |
| |
| pfw_test_tools=os.environ["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.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", expectSuccess=None) |
| 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) |
| |
| 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 |
| domainBackup = out.strip('\r\n').splitlines() |
| log.I("Actual domains: %s" % domainBackup) |
| assert len(domainBackup)==self.nb_domains_in_reference_xml, log.F("Number of listed domains is not compliant with the file %s - expected : %s domains, found domains %s"%(self.reference_xml,self.nb_domains_in_reference_xml, domainBackup)) |
| |
| #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.strip('\r\n')) |
| 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], config_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 open(self.filesystem_01).read()[:-1] == 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 open(self.filesystem_02).read()[:-1] == 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 open(self.filesystem_03).read()[:-1] == 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 = open(self.filesystem_01).read()[:-1] |
| init_filesystem_02 = open(self.filesystem_02).read()[:-1] |
| init_filesystem_03 = open(self.filesystem_03).read()[:-1] |
| |
| ### 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 open(self.filesystem_01).read()[:-1] != 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 open(self.filesystem_02).read()[:-1] != 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 open(self.filesystem_03).read()[:-1] != 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 open(self.filesystem_01).read()[:-1] == 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 open(self.filesystem_02).read()[:-1] == 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 open(self.filesystem_03).read()[:-1] == 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 = open(self.filesystem_01).read()[:-1] |
| init_filesystem_02 = open(self.filesystem_02).read()[:-1] |
| init_filesystem_03 = open(self.filesystem_03).read()[:-1] |
| |
| ### 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 open(self.filesystem_01).read()[:-1] != 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 open(self.filesystem_02).read()[:-1] != 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 open(self.filesystem_03).read()[:-1] != 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 open(self.filesystem_01).read()[:-1] != 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 open(self.filesystem_02).read()[:-1] != 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 open(self.filesystem_03).read()[:-1] != 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 open(self.filesystem_01).read()[:-1] != 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 open(self.filesystem_02).read()[:-1] != 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 open(self.filesystem_03).read()[:-1] != 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 |
| 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 = open(self.filesystem_01).read()[:-1] |
| init_filesystem_02 = open(self.filesystem_02).read()[:-1] |
| init_filesystem_03 = open(self.filesystem_03).read()[:-1] |
| xml_path=os.environ["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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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.strip('\r\n')) |
| 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.strip('\r\n')) |
| 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 open(self.filesystem_01).read()[:-1] == 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 open(self.filesystem_02).read()[:-1] == 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 open(self.filesystem_03).read()[:-1] == 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 |
| 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=os.environ["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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| #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, "", expectSuccess=False) |
| 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, "", expectSuccess=False) |
| 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.strip('\r\n')) |
| 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 domains, found domains: %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.strip('\r\n')) |
| 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 #### |
