1# -*-coding:utf-8 -* 2 3# Copyright (c) 2011-2015, Intel Corporation 4# All rights reserved. 5# 6# Redistribution and use in source and binary forms, with or without modification, 7# are permitted provided that the following conditions are met: 8# 9# 1. Redistributions of source code must retain the above copyright notice, this 10# list of conditions and the following disclaimer. 11# 12# 2. Redistributions in binary form must reproduce the above copyright notice, 13# this list of conditions and the following disclaimer in the documentation and/or 14# other materials provided with the distribution. 15# 16# 3. Neither the name of the copyright holder nor the names of its contributors 17# may be used to endorse or promote products derived from this software without 18# specific prior written permission. 19# 20# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 21# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 22# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 23# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 24# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 25# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 27# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 29# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31""" 32Export and import settings and domains from file testcases 33 34List of tested functions : 35-------------------------- 36 - [exportDomainsWithSettingsXML] function 37 - [importDomainsWithSettingsXML] function 38 - [exportDomainsXML] function 39 - [importDomainsXML] function 40 41Test cases : 42------------ 43 - Testing importDomainsWithSettingsXML nominal case 44 - Testing exportDomainsWithSettingsXML nominal case 45 - Testing exportDomainsXML/importDomainsXML nominal case 46 - Testing import errors 47 - Testing export errors 48""" 49import os, commands 50import unittest 51from Util.PfwUnitTestLib import PfwTestCase 52from Util import ACTLogging 53log=ACTLogging.Logger() 54 55class TestCases(PfwTestCase): 56 57 def setUp(self): 58 59 self.pfw.sendCmd("setTuningMode", "on") 60 self.param_name_01 = "/Test/Test/TEST_DIR/UINT16" 61 self.filesystem_01 = os.environ["PFW_RESULT"] + "/UINT16" 62 self.param_name_02 = "/Test/Test/TEST_DOMAIN_0/Param_00" 63 self.filesystem_02 = os.environ["PFW_RESULT"] + "/Param_00" 64 self.param_name_03 = "/Test/Test/TEST_DOMAIN_1/Param_12" 65 self.filesystem_03 = os.environ["PFW_RESULT"] + "/Param_12" 66 67 pfw_test_tools=os.environ["PFW_TEST_TOOLS"] 68 self.reference_xml = pfw_test_tools+"/xml/XML_Test/Reference_Compliant.xml" 69 self.initial_xml = pfw_test_tools+"/xml/TestConfigurableDomains.xml" 70 self.temp_config="f_Config_Backup" 71 self.temp_domain="f_Domains_Backup" 72 self.temp_xml=pfw_test_tools+"/f_temp.xml" 73 74 self.nb_domains_in_reference_xml=3 75 self.nb_conf_per_domains_in_reference_xml=[2,2,2] 76 77 def tearDown(self): 78 self.pfw.sendCmd("setTuningMode", "off", expectSuccess=None) 79 if os.path.exists(self.temp_domain): 80 os.remove(self.temp_domain) 81 if os.path.exists(self.temp_config): 82 os.remove(self.temp_config) 83 if os.path.exists(self.temp_xml): 84 os.remove(self.temp_xml) 85 86 def test_01_importDomainsWithSettingsXML_Nominal_Case(self): 87 """ 88 Testing importDomainsWithSettingsXML nominal case 89 ------------------------------------------------- 90 Test case description : 91 ~~~~~~~~~~~~~~~~~~~~~~~ 92 - import a reference XML 93 - check Domains 94 - check Configuration 95 - restore Configuration 96 - check Parameters 97 Tested commands : 98 ~~~~~~~~~~~~~~~~~ 99 - [createConfiguration] function 100 Used commands : 101 ~~~~~~~~~~~~~~~ 102 - [restoreConfiguration] function 103 - [listDomains] function 104 - [listConfiguration] function 105 - [getRules] function 106 - [getParameter] function 107 Expected result : 108 ~~~~~~~~~~~~~~~~~ 109 - all operations succeed 110 """ 111 log.D(self.test_01_importDomainsWithSettingsXML_Nominal_Case.__doc__) 112 113 #Import a reference XML file 114 log.I("Import Domains with settings from %s"%(self.reference_xml)) 115 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "") 116 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err)) 117 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml)) 118 119 #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared) 120 # Domains listing using "listDomains" command 121 log.I("Current domains listing") 122 log.I("Command [listDomains]") 123 out, err = self.pfw.sendCmd("listDomains","","") 124 assert err == None, log.E("Command [listDomains] : %s"%(err)) 125 log.I("Command [listDomains] - correctly executed") 126 # Domains listing backup 127 domainBackup = out.strip('\r\n').splitlines() 128 log.I("Actual domains: %s" % domainBackup) 129 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)) 130 131 #Check number of config per domain(2 config per domains are setup in the reference XML) 132 # Config listing 133 domain_basename="Domain_" 134 for index in range(self.nb_domains_in_reference_xml): 135 domain_name=domain_basename+str(index+1) 136 log.I("Listing config for domain %s"%(domain_name)) 137 out, err = self.pfw.sendCmd("listConfigurations",domain_name,"") 138 assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err)) 139 log.I("Command [listConfigurations %s] - correctly executed"%(domain_name)) 140 f_Config_Backup = open(self.temp_config, "w") 141 f_Config_Backup.write(out.strip('\r\n')) 142 f_Config_Backup.close() 143 f_Config_Backup = open(self.temp_config, "r") 144 config_nbr = 0 145 line=f_Config_Backup.readline() 146 while line!="": 147 line=f_Config_Backup.readline() 148 config_nbr+=1 149 f_Config_Backup.close() 150 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)) 151 log.I("Config checking : OK") 152 153 #Check number of config per domain(2 config per domains are setup in the reference XML) 154 # Config listing 155 conf_basename="Conf_" 156 for index_domain in range(3): 157 for index_conf in range(2): 158 domain_name=domain_basename+str(index_domain+1) 159 conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf) 160 log.I("Get rule for domain %s - conf %s"%(domain_name,conf_name)) 161 out, err = self.pfw.sendCmd("getRule",domain_name,conf_name) 162 assert err == None, log.E("Command [getRules %s %s] : %s"%(domain_name,conf_name,err)) 163 assert out !="", log.F("No rules loaded for domain %s conf %s"%(domain_name,conf_name)) 164 log.I("Rules checking : OK") 165 166 #Restore config 167 conf_basename="Conf_" 168 for index_domain in range(3): 169 for index_conf in range(2): 170 domain_name=domain_basename+str(index_domain+1) 171 conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf) 172 log.I("Restore config %s for domain %s"%(conf_name,domain_name)) 173 out, err = self.pfw.sendCmd("restoreConfiguration",domain_name,conf_name) 174 assert err == None, log.E("Command [restoreConfiguration %s %s] : %s"%(domain_name,conf_name,err)) 175 assert out =="Done", log.F("When restoring configuration %s for domain %s"%(conf_name,domain_name)) 176 log.I("Restore configurations: OK") 177 178 #set Tuning Mode off to check parameter value 179 self.pfw.sendCmd("setTuningMode", "off") 180 181 #Check parameter values 182 #UINT16 183 expected_value="0" 184 hex_value="0x0" 185 log.I("UINT16 parameter in the conf Conf_1_1= %s"%(expected_value)) 186 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 187 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 188 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out)) 189 #Check parameter value on filesystem 190 assert open(self.filesystem_01).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 191 #Param_00 192 expected_value="4" 193 hex_value="0x4" 194 log.I("Param_00 parameter in the conf Conf_2_1= %s"%(expected_value)) 195 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 196 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 197 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out)) 198 #Check parameter value on filesystem 199 assert open(self.filesystem_02).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 200 #Param_12 201 expected_value="4" 202 hex_value="0x4" 203 log.I("Param_12 parameter in the conf Conf_3_1= %s"%(expected_value)) 204 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 205 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 206 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out)) 207 #Check parameter value on filesystem 208 assert open(self.filesystem_03).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 209 log.I("Parameters checking : OK") 210 211 def test_02_exportDomainsWithSettingsXML_Nominal_Case(self): 212 """ 213 Testing exportDomainsWithSettingsXML nominal case 214 ------------------------------------------------- 215 Test case description : 216 ~~~~~~~~~~~~~~~~~~~~~~~ 217 - export domains with settings in temp XML 218 - import a reference XML 219 - restore Configuration 220 - import the temp XML 221 - restore Configuration 222 - check Domains 223 - check Configuration 224 - check Parameters 225 Tested commands : 226 ~~~~~~~~~~~~~~~~~ 227 - [exportDomainsWithSettingsXML] function 228 - [importDomainsWithSettingsXML] function 229 Used commands : 230 ~~~~~~~~~~~~~~~ 231 - [restoreConfiguration] function 232 - [listDomains] function 233 - [listConfiguration] function 234 - [getRules] function 235 - [getParameter] function 236 Expected result : 237 ~~~~~~~~~~~~~~~~~ 238 - all operations succeed 239 """ 240 log.D(self.test_02_exportDomainsWithSettingsXML_Nominal_Case.__doc__) 241 242 ### INIT Domains Settings #### 243 244 #Import a reference XML file 245 246 log.I("Import Domains with initial settings from %s"%(self.reference_xml)) 247 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "") 248 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err)) 249 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml)) 250 self.pfw.sendCmd("setTuningMode", "off","") 251 init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 252 init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 253 init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 254 init_filesystem_01 = open(self.filesystem_01).read()[:-1] 255 init_filesystem_02 = open(self.filesystem_02).read()[:-1] 256 init_filesystem_03 = open(self.filesystem_03).read()[:-1] 257 258 ### END OF INIT ### 259 260 #Export in a temp XML file 261 log.I("Export Domains with initial settings in %s"%(self.temp_xml)) 262 out, err = self.pfw.sendCmd("exportDomainsWithSettingsXML",self.temp_xml, "") 263 assert err == None, log.E("Command [exportDomainsWithSettingsXML %s] : %s"%(self.temp_xml,err)) 264 assert out == "Done", log.F("When using function exportDomainsWithSettingsXML %s]"%(self.temp_xml)) 265 266 #Change the value of checked parameters 267 self.pfw.sendCmd("setTuningMode", "on","") 268 out, err = self.pfw.sendCmd("setParameter", self.param_name_01, str(int(init_value_01)+1)) 269 out, err = self.pfw.sendCmd("setParameter", self.param_name_02, str(int(init_value_02)+1)) 270 out, err = self.pfw.sendCmd("setParameter", self.param_name_03, str(int(init_value_03)+1)) 271 #save config 272 domain_basename="Domain_" 273 conf_basename="Conf_" 274 for index_domain in range(3): 275 for index_conf in range(2): 276 domain_name=domain_basename+str(index_domain+1) 277 conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf) 278 log.I("Save config %s for domain %s"%(conf_name,domain_name)) 279 out, err = self.pfw.sendCmd("saveConfiguration",domain_name,conf_name) 280 assert err == None, log.E("Command [saveConfiguration %s %s] : %s"%(domain_name,conf_name,err)) 281 assert out =="Done", log.F("When saving configuration %s for domain %s"%(conf_name,domain_name)) 282 log.I("Save configurations: OK") 283 self.pfw.sendCmd("setTuningMode", "off","") 284 285 #Check parameter values 286 #UINT16 287 expected_value=str(int(init_value_01)+1) 288 log.I("UINT16 parameter = %s"%(expected_value)) 289 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 290 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 291 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out)) 292 #Check parameter value on filesystem 293 assert open(self.filesystem_01).read()[:-1] != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 294 #Param_00 295 expected_value=str(int(init_value_02)+1) 296 log.I("Param_00 parameter= %s"%(expected_value)) 297 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 298 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 299 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out)) 300 #Check parameter value on filesystem 301 assert open(self.filesystem_02).read()[:-1] != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 302 #Param_12 303 expected_value=str(int(init_value_03)+1) 304 log.I("Param_12 parameter= %s"%(expected_value)) 305 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 306 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 307 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out)) 308 #Check parameter value on filesystem 309 assert open(self.filesystem_03).read()[:-1] != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 310 311 #Import the temp XML file 312 self.pfw.sendCmd("setTuningMode", "on","") 313 log.I("Import Domains with settings from %s"%(self.temp_xml)) 314 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.temp_xml, "") 315 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.temp_xml,err)) 316 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.temp_xml)) 317 self.pfw.sendCmd("setTuningMode", "off","") 318 319 #Check parameter values 320 #UINT16 321 expected_value=init_value_01 322 log.I("UINT16 parameter = %s"%(expected_value)) 323 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 324 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 325 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out)) 326 #Check parameter value on filesystem 327 assert open(self.filesystem_01).read()[:-1] == init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 328 #Param_00 329 expected_value=init_value_02 330 log.I("Param_00 parameter= %s"%(expected_value)) 331 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 332 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 333 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out)) 334 #Check parameter value on filesystem 335 assert open(self.filesystem_02).read()[:-1] == init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 336 #Param_12 337 expected_value=init_value_03 338 log.I("Param_12 parameter= %s"%(expected_value)) 339 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 340 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 341 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out)) 342 #Check parameter value on filesystem 343 assert open(self.filesystem_03).read()[:-1] == init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 344 345 def test_03_exportImportXML_withoutSettings_Nominal_Case(self): 346 """ 347 Testing exportDomainsXML/importDomainsXML nominal case 348 ------------------------------------------------------ 349 Test case description : 350 ~~~~~~~~~~~~~~~~~~~~~~~ 351 - export domains in temp XML 352 - import a reference XML 353 - restore Configuration 354 - import the temp XML 355 - restore Configuration 356 - check Domains 357 - check Configuration 358 - check Parameters 359 Tested commands : 360 ~~~~~~~~~~~~~~~~~ 361 - [exportDomainsXML] function 362 - [importDomainsWithSettingsXML] function 363 - [importDomainsXML] function 364 Used commands : 365 ~~~~~~~~~~~~~~~ 366 - [restoreConfiguration] function 367 - [listDomains] function 368 - [listConfiguration] function 369 - [getRules] function 370 - [getParameter] function 371 Expected result : 372 ~~~~~~~~~~~~~~~~~ 373 - all operations succeed 374 - parameter must not change 375 """ 376 log.D(self.test_03_exportImportXML_withoutSettings_Nominal_Case.__doc__) 377 378 ### INIT Domains Settings #### 379 380 #Import a reference XML file 381 382 log.I("Import Domains with initial settings from %s"%(self.reference_xml)) 383 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "") 384 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err)) 385 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml)) 386 self.pfw.sendCmd("setTuningMode", "off","") 387 init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 388 init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 389 init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 390 init_filesystem_01 = open(self.filesystem_01).read()[:-1] 391 init_filesystem_02 = open(self.filesystem_02).read()[:-1] 392 init_filesystem_03 = open(self.filesystem_03).read()[:-1] 393 394 ### END OF INIT ### 395 396 #Export domains without settings in a temp XML file 397 log.I("Export Domains without initial settings in %s"%(self.temp_xml)) 398 out, err = self.pfw.sendCmd("exportDomainsXML",self.temp_xml, "") 399 assert err == None, log.E("Command [exportDomainsXML %s] : %s"%(self.temp_xml,err)) 400 assert out == "Done", log.F("When using function exportDomainsXML %s]"%(self.temp_xml)) 401 402 #Change the value of checked parameters 403 self.pfw.sendCmd("setTuningMode", "on","") 404 out, err = self.pfw.sendCmd("setParameter", self.param_name_01, str(int(init_value_01)+1)) 405 out, err = self.pfw.sendCmd("setParameter", self.param_name_02, str(int(init_value_02)+1)) 406 out, err = self.pfw.sendCmd("setParameter", self.param_name_03, str(int(init_value_03)+1)) 407 #save config 408 domain_basename="Domain_" 409 conf_basename="Conf_" 410 for index_domain in range(3): 411 for index_conf in range(2): 412 domain_name=domain_basename+str(index_domain+1) 413 conf_name=conf_basename+str(index_domain+1)+"_"+str(index_conf) 414 log.I("Save config %s for domain %s"%(conf_name,domain_name)) 415 out, err = self.pfw.sendCmd("saveConfiguration",domain_name,conf_name) 416 assert err == None, log.E("Command [saveConfiguration %s %s] : %s"%(domain_name,conf_name,err)) 417 assert out =="Done", log.F("When saving configuration %s for domain %s"%(conf_name,domain_name)) 418 log.I("Save configurations: OK") 419 self.pfw.sendCmd("setTuningMode", "off","") 420 421 #Check parameter values 422 #UINT16 423 expected_value=str(int(init_value_01)+1) 424 log.I("UINT16 parameter = %s"%(expected_value)) 425 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 426 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 427 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out)) 428 #Check parameter value on filesystem 429 assert open(self.filesystem_01).read()[:-1] != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 430 #Param_00 431 expected_value=str(int(init_value_02)+1) 432 log.I("Param_00 parameter= %s"%(expected_value)) 433 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 434 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 435 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out)) 436 #Check parameter value on filesystem 437 assert open(self.filesystem_02).read()[:-1] != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 438 #Param_12 439 expected_value=str(int(init_value_03)+1) 440 log.I("Param_12 parameter= %s"%(expected_value)) 441 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 442 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 443 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out)) 444 #Check parameter value on filesystem 445 assert open(self.filesystem_03).read()[:-1] != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 446 447 #Import the temp XML file without 448 self.pfw.sendCmd("setTuningMode", "on","") 449 log.I("Import Domains without settings from %s"%(self.temp_xml)) 450 out, err = self.pfw.sendCmd("importDomainsXML",self.temp_xml, "") 451 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(self.temp_xml,err)) 452 assert out == "Done", log.F("When using function importDomainsXML %s]"%(self.temp_xml)) 453 self.pfw.sendCmd("setTuningMode", "off","") 454 455 #Check parameter values 456 #UINT16 457 unexpected_value=init_value_01 458 log.I("UINT16 parameter = %s"%(unexpected_value)) 459 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 460 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 461 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_01, out)) 462 #Check parameter value on filesystem 463 assert open(self.filesystem_01).read()[:-1] != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 464 #Param_00 465 unexpected_value=init_value_02 466 log.I("Param_00 parameter= %s"%(unexpected_value)) 467 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 468 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 469 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_02, out)) 470 #Check parameter value on filesystem 471 assert open(self.filesystem_02).read()[:-1] != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 472 #Param_12 473 unexpected_value=init_value_03 474 log.I("Param_12 parameter= %s"%(unexpected_value)) 475 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 476 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 477 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s"% (self.param_name_03, out)) 478 #Check parameter value on filesystem 479 assert open(self.filesystem_03).read()[:-1] != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 480 481 #Import the reference_XML file without settings 482 self.pfw.sendCmd("setTuningMode", "on","") 483 log.I("Import Domains without settings from %s"%(self.reference_xml)) 484 out, err = self.pfw.sendCmd("importDomainsXML",self.reference_xml, "") 485 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(self.reference_xml,err)) 486 assert out == "Done", log.F("When using function importDomainsXML %s]"%(self.reference_xml)) 487 self.pfw.sendCmd("setTuningMode", "off","") 488 489 #Check parameter values 490 #UINT16 491 unexpected_value=init_value_01 492 log.I("UINT16 parameter = %s"%(unexpected_value)) 493 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 494 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 495 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_01, out)) 496 #Check parameter value on filesystem 497 assert open(self.filesystem_01).read()[:-1] != init_filesystem_01, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 498 #Param_00 499 unexpected_value=init_value_02 500 log.I("Param_00 parameter= %s"%(unexpected_value)) 501 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 502 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 503 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_02, out)) 504 #Check parameter value on filesystem 505 assert open(self.filesystem_02).read()[:-1] != init_filesystem_02, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 506 #Param_12 507 unexpected_value=init_value_03 508 log.I("Param_12 parameter= %s"%(unexpected_value)) 509 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 510 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 511 assert out != unexpected_value, log.F("BLACKBOARD : Unexpected value found for %s: %s" % (self.param_name_03, out)) 512 #Check parameter value on filesystem 513 assert open(self.filesystem_03).read()[:-1] != init_filesystem_03, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 514 515 @unittest.expectedFailure 516 def test_05_Import_XML_With_Settings_Error_Case(self): 517 """ 518 Testing importDomainsWithSettingsXML error case 519 ----------------------------------------------- 520 Test case description : 521 ~~~~~~~~~~~~~~~~~~~~~~~ 522 - import with settings non-compliant XML 523 - import with settings a non-existing XML file 524 - check Domains 525 - check Configuration 526 - check Parameters 527 Tested commands : 528 ~~~~~~~~~~~~~~~~~ 529 - [importDomainsWithSettingsXML] function 530 - [importDomainsXML] function 531 Used commands : 532 ~~~~~~~~~~~~~~~ 533 - [restoreConfiguration] function 534 - [listDomains] function 535 - [listConfiguration] function 536 - [getRules] function 537 - [getParameter] function 538 Expected result : 539 ~~~~~~~~~~~~~~~~~ 540 - all errors are detected, initial domains keep settings 541 """ 542 log.D(self.test_05_Import_XML_With_Settings_Error_Case.__doc__) 543 544 ### INIT Domains Settings #### 545 #Import a reference XML file 546 547 log.I("Import Domains with initial settings from %s"%(self.reference_xml)) 548 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "") 549 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err)) 550 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml)) 551 552 self.pfw.sendCmd("setTuningMode", "off","") 553 init_value_01, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 554 init_value_02, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 555 init_value_03, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 556 init_filesystem_01 = open(self.filesystem_01).read()[:-1] 557 init_filesystem_02 = open(self.filesystem_02).read()[:-1] 558 init_filesystem_03 = open(self.filesystem_03).read()[:-1] 559 xml_path=os.environ["PFW_TEST_TOOLS"] + "/xml/XML_Test/" 560 ### END OF INIT ### 561 562 self.pfw.sendCmd("setTuningMode", "on","") 563 #Import domains and settings from xml with outbound parameter value 564 xml_name="Uncompliant_OutboundParameter.xml" 565 log.I("Import %s with initial settings"%(xml_name)) 566 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "", expectSuccess=False) 567 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err)) 568 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 569 log.I("Test OK : %s is not imported"%(xml_name)) 570 #Import domains and settings from xml using undeclared configurable element 571 xml_name="Uncompliant_UndeclaredConfigurableElement.xml" 572 log.I("Import %s with initial settings"%(xml_name)) 573 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "", expectSuccess=False) 574 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err)) 575 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 576 log.I("Test OK : %s is not imported"%(xml_name)) 577 #Import domains and settings from xml using undeclared parameter 578 xml_name="Uncompliant_UndeclaredParameter.xml" 579 log.I("Import %s with initial settings"%(xml_name)) 580 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "", expectSuccess=False) 581 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err)) 582 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 583 log.I("Test OK : %s is not imported"%(xml_name)) 584 #Import domains and settings from xml using wrong order of configurable element 585 xml_name="Uncompliant_UnorderConfigurableElement.xml" 586 log.I("Import %s with initial settings"%(xml_name)) 587 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "", expectSuccess=False) 588 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err)) 589 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 590 log.I("Test OK : %s is not imported"%(xml_name)) 591 #Import domains and settings from unexistent xml 592 xml_name="Unexistent.xml" 593 log.I("Import %s with initial settings"%(xml_name)) 594 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",xml_path+xml_name, "", expectSuccess=False) 595 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(xml_path+xml_name,err)) 596 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 597 log.I("Test OK : %s is not imported"%(xml_name)) 598 self.pfw.sendCmd("setTuningMode", "off","") 599 600 #### check domains and settings #### 601 602 #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared) 603 # Domains listing using "listDomains" command 604 log.I("Current domains listing") 605 log.I("Command [listDomains]") 606 out, err = self.pfw.sendCmd("listDomains","","") 607 assert err == None, log.E("Command [listDomains] : %s"%(err)) 608 log.I("Command [listDomains] - correctly executed") 609 # Domains listing backup 610 f_Domains_Backup = open(self.temp_domain, "w") 611 f_Domains_Backup.write(out.strip('\r\n')) 612 f_Domains_Backup.close() 613 f_Domains_Backup = open(self.temp_domain, "r") 614 domains_nbr = 0 615 line=f_Domains_Backup.readline() 616 while line!="": 617 line=f_Domains_Backup.readline() 618 domains_nbr+=1 619 f_Domains_Backup.close() 620 log.I("Actual domains number : %s" % domains_nbr) 621 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)) 622 #Check number of config per domain(2 config per domains are setup in the reference XML) 623 # Config listing 624 domain_basename="Domain_" 625 for index in range(self.nb_domains_in_reference_xml): 626 domain_name=domain_basename+str(index+1) 627 log.I("Listing config for domain %s"%(domain_name)) 628 out, err = self.pfw.sendCmd("listConfigurations",domain_name,"") 629 assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err)) 630 log.I("Command [listConfigurations %s] - correctly executed"%(domain_name)) 631 f_Config_Backup = open(self.temp_config, "w") 632 f_Config_Backup.write(out.strip('\r\n')) 633 f_Config_Backup.close() 634 f_Config_Backup = open(self.temp_config, "r") 635 config_nbr = 0 636 line=f_Config_Backup.readline() 637 while line!="": 638 line=f_Config_Backup.readline() 639 config_nbr+=1 640 f_Config_Backup.close() 641 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)) 642 log.I("Config checking : OK") 643 #Check parameter values 644 #UINT16 645 expected_value=init_value_01 646 hex_value=init_filesystem_01 647 log.I("UINT16 parameter in the conf Conf_1_1= %s"%(expected_value)) 648 out, err = self.pfw.sendCmd("getParameter", self.param_name_01, "") 649 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_01, err)) 650 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_01, expected_value, out)) 651 #Check parameter value on filesystem 652 assert open(self.filesystem_01).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_01) 653 #Param_00 654 expected_value=init_value_02 655 hex_value=init_filesystem_02 656 log.I("Param_00 parameter in the conf Conf_2_1= %s"%(expected_value)) 657 out, err = self.pfw.sendCmd("getParameter", self.param_name_02, "") 658 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_02, err)) 659 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_02, expected_value, out)) 660 #Check parameter value on filesystem 661 assert open(self.filesystem_02).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_02) 662 #Param_12 663 expected_value=init_value_03 664 hex_value=init_filesystem_03 665 log.I("Param_12 parameter in the conf Conf_3_1= %s"%(expected_value)) 666 out, err = self.pfw.sendCmd("getParameter", self.param_name_03, "") 667 assert err == None, log.E("When setting parameter %s : %s" % (self.param_name_03, err)) 668 assert out == expected_value, log.F("BLACKBOARD : Incorrect value for %s, expected: %s, found: %s" % (self.param_name_03, expected_value, out)) 669 #Check parameter value on filesystem 670 assert open(self.filesystem_03).read()[:-1] == hex_value, log.F("FILESYSTEM : parameter %s update error"%self.param_name_03) 671 log.I("Parameters checking : OK") 672 673 #### END check domains and settings #### 674 675 676 @unittest.expectedFailure 677 def test_06_Import_XML_Without_Settings_Error_Case(self): 678 """ 679 Testing import XML without settings error case 680 ---------------------------------------------- 681 Test case description : 682 ~~~~~~~~~~~~~~~~~~~~~~~ 683 - import non-compliant XML 684 - import a non-existing XML files 685 - import a reference XML 686 - check Domains 687 - check Configuration 688 - check Parameters 689 Tested commands : 690 ~~~~~~~~~~~~~~~~~ 691 - [importDomainsWithSettingsXML] function 692 - [importDomainsXML] function 693 Used commands : 694 ~~~~~~~~~~~~~~~ 695 - [restoreConfiguration] function 696 - [listDomains] function 697 - [listConfiguration] function 698 - [getRules] function 699 - [getParameter] function 700 Expected result : 701 ~~~~~~~~~~~~~~~~~ 702 - all errors are detected, initial domains keep settings 703 """ 704 log.D(self.test_06_Import_XML_Without_Settings_Error_Case.__doc__) 705 706 ### INIT Domains Settings #### 707 #Import a reference XML file 708 709 log.I("Import Domains with initial settings from %s"%(self.reference_xml)) 710 out, err = self.pfw.sendCmd("importDomainsWithSettingsXML",self.reference_xml, "") 711 assert err == None, log.E("Command [importDomainsWithSettingsXML %s] : %s"%(self.reference_xml,err)) 712 assert out == "Done", log.F("When using function importDomainsWithSettingsXML %s]"%(self.reference_xml)) 713 714 self.pfw.sendCmd("setTuningMode", "off","") 715 xml_path=os.environ["PFW_TEST_TOOLS"] + "/xml/XML_Test/" 716 ### END OF INIT ### 717 718 self.pfw.sendCmd("setTuningMode", "on","") 719 #Import domains from xml with outbound parameter value 720 xml_name="Uncompliant_OutboundParameter.xml" 721 log.I("Import %s without settings"%(xml_name)) 722 out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "", expectSuccess=False) 723 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err)) 724 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 725 log.I("Test OK : %s is not imported"%(xml_name)) 726 #Import domains from xml using undeclared configurable element 727 xml_name="Uncompliant_UndeclaredConfigurableElement.xml" 728 log.I("Import %s without settings"%(xml_name)) 729 out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "", expectSuccess=False) 730 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err)) 731 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 732 log.I("Test OK : %s is not imported"%(xml_name)) 733 #Import domains from xml using undeclared parameter 734 #xml_name="Uncompliant_UndeclaredParameter.xml" 735 #log.I("Import %s without settings"%(xml_name)) 736 #out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "", expectSuccess=False) 737 #assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err)) 738 #assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 739 #log.I("Test OK : %s is not imported"%(xml_name)) 740 #Import domains from xml using wrong order of configurable element 741 xml_name="Uncompliant_UnorderConfigurableElement.xml" 742 log.I("Import %s without settings"%(xml_name)) 743 out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "", expectSuccess=False) 744 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err)) 745 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 746 log.I("Test OK : %s is not imported"%(xml_name)) 747 #Import domains from unexistent xml 748 xml_name="Unexistent.xml" 749 log.I("Import %s without settings"%(xml_name)) 750 out, err = self.pfw.sendCmd("importDomainsXML",xml_path+xml_name, "", expectSuccess=False) 751 assert err == None, log.E("Command [importDomainsXML %s] : %s"%(xml_path+xml_name,err)) 752 assert out != "Done", log.F("Error not detected when imported %s]"%(xml_path+xml_name)) 753 log.I("Test OK : %s is not imported"%(xml_name)) 754 self.pfw.sendCmd("setTuningMode", "off","") 755 756 #### check domains and settings #### 757 758 #Check number of domain(3 domains are setup in the reference XML, initially only one domains is declared) 759 # Domains listing using "listDomains" command 760 log.I("Current domains listing") 761 log.I("Command [listDomains]") 762 out, err = self.pfw.sendCmd("listDomains","","") 763 assert err == None, log.E("Command [listDomains] : %s"%(err)) 764 log.I("Command [listDomains] - correctly executed") 765 # Domains listing backup 766 f_Domains_Backup = open(self.temp_domain, "w") 767 f_Domains_Backup.write(out.strip('\r\n')) 768 f_Domains_Backup.close() 769 f_Domains_Backup = open(self.temp_domain, "r") 770 domains_nbr = 0 771 line=f_Domains_Backup.readline() 772 while line!="": 773 line=f_Domains_Backup.readline() 774 domains_nbr+=1 775 f_Domains_Backup.close() 776 log.I("Actual domains number : %s" % domains_nbr) 777 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)) 778 #Check number of config per domain(2 config per domains are setup in the reference XML) 779 # Config listing 780 domain_basename="Domain_" 781 for index in range(self.nb_domains_in_reference_xml): 782 domain_name=domain_basename+str(index+1) 783 log.I("Listing config for domain %s"%(domain_name)) 784 out, err = self.pfw.sendCmd("listConfigurations",domain_name,"") 785 assert err == None, log.E("Command [listConfigurations %s] : %s"%(domain_name,err)) 786 log.I("Command [listConfigurations %s] - correctly executed"%(domain_name)) 787 f_Config_Backup = open(self.temp_config, "w") 788 f_Config_Backup.write(out.strip('\r\n')) 789 f_Config_Backup.close() 790 f_Config_Backup = open(self.temp_config, "r") 791 config_nbr = 0 792 line=f_Config_Backup.readline() 793 while line!="": 794 line=f_Config_Backup.readline() 795 config_nbr+=1 796 f_Config_Backup.close() 797 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)) 798 log.I("Config checking : OK") 799 800 #### END check domains and settings #### 801