1 # -*- encoding: latin-1 -*-

     2 

     3 #============================================================================ 

     4 #Name        : test_ats4.py 

     5 #Part of     : Helium 

     6 

     7 #Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     8 #All rights reserved.

     9 #This component and the accompanying materials are made available

    10 #under the terms of the License "Eclipse Public License v1.0"

    11 #which accompanies this distribution, and is available

    12 #at the URL "http://www.eclipse.org/legal/epl-v10.html".

    13 #

    14 #Initial Contributors:

    15 #Nokia Corporation - initial contribution.

    16 #

    17 #Contributors:

    18 #

    19 #Description:

    20 #===============================================================================

    21 

    22 """ Testing ats4 framework. """

    23 # pylint: disable-msg=E1101, C0302, W0142, W0603, R0902,R0903,R0912,R0915

    24 #E1101 => Mocker shows mockery

    25 #C0302 => too many lines

    26 #W0142 => used * or ** magic 

    27 #W0603 => used global

    28 #R* during refactoring

    29 

    30 from cStringIO import StringIO

    31 from xml.etree.ElementTree import fromstring

    32 from xml.etree import ElementTree as et

    33 import difflib

    34 import logging

    35 logging.getLogger().setLevel(logging.ERROR)

    36 import tempfile

    37 import zipfile

    38 import os

    39 import re

    40 import subprocess

    41 import fileutils

    42 

    43 from path import path # pylint: disable-msg=F0401

    44 import amara

    45 import mocker # pylint: disable-msg=F0401

    46 

    47 import ntpath

    48 

    49 import ats3

    50 import ats3.testconfigurator as atc

    51 import ats3.dropgenerator as adg

    52 import ats3.parsers as parser

    53 

    54 

    55 TEST_PATH = None

    56 TEST_FILES = {}

    57 TSRC = None

    58 OUTPUT = None

    59 

    60 # Shortcuts

    61 E = et.Element

    62 SE = et.SubElement

    63 

    64 class Bunch(object):

    65     """ Configuration object. Argument from constructor are converted into class attributes. """

    66     def __init__(self, **kwargs):

    67         self.__dict__.update(kwargs)

    68         

    69 def equal_xml(xml1, xml2):

    70     """Check the equality of the given XML snippets.

    71     

    72     Tag name equality:

    73     

    74     >>> equal_xml('<a/>', '<a/>')

    75     True

    76     >>> equal_xml('<a/>', '<b/>')

    77     False

    78     

    79     Attribute equality:

    80     

    81     >>> equal_xml('<a k="v"/>', '<a k="v"/>')

    82     True

    83     >>> equal_xml('<a k="v"/>', '<a k="w"/>')

    84     False

    85     

    86     Text content equality:

    87     

    88     >>> equal_xml('<a>v</a>', '<a>v</a>')

    89     True

    90     >>> equal_xml('<a>v</a>', '<a>w</a>')

    91     False

    92     >>> equal_xml('<a>v</a>', '<a></a>')

    93     False

    94     

    95     Text content equality when whitespace differs:

    96     >>> equal_xml('<a>v</a>', '<a>v </a>')

    97     True

    98 

    99     Equality of child elements:

   100     

   101     >>> equal_xml('<a><b><c k="v"/></b></a>', '<a><b><c k="v"/></b></a>')

   102     True

   103     >>> equal_xml('<a><b><c k="v"/></b></a>', '<a><b><c k="w"/></b></a>')

   104     False

   105     >>> equal_xml('<a><b><c k="v"/>v</b></a>', '<a><b><c k="v"/>w</b></a>')

   106     False

   107     >>> equal_xml('<a><b><c k="v"/>v</b></a>', '<a><b><c k="v"/>v </b></a>')

   108     True

   109     

   110     """

   111     def __init__():

   112         check_instance(xml1, xml2)

   113     

   114     def check_instance(xml1, xml2):

   115         """if xml1 and xml2 are instances, converts to strings"""

   116         if isinstance(xml1, basestring):

   117             xml1 = fromstring(xml1)

   118         if isinstance(xml2, basestring):

   119             xml2 = fromstring(xml2)

   120         check_tags(xml1, xml2)

   121 

   122     def check_tags(xml1, xml2):

   123         """check xml tags and text equality"""

   124         if xml1.tag != xml2.tag:

   125             return False

   126         if xml1.attrib != xml2.attrib:

   127             return False

   128         if xml1.text:

   129             if not xml2.text:

   130                 return False

   131         if xml2.text:

   132             if not xml1.text:

   133                 return False

   134 

   135         produce_xml_children(xml1, xml2)

   136 

   137     def produce_xml_children(xml1, xml2):

   138         """checks if xml children are of same length and are equal?"""

   139         if xml1.text and xml2.text and xml1.text.strip() != xml2.text.strip():

   140             return False

   141         if xml1.tail is not None and xml2.tail is not None:

   142             if xml1.tail.strip() != xml2.tail.strip():

   143                 return False

   144         elif xml1.tail != xml2.tail:

   145             return False

   146         

   147         children1 = list(xml1.getchildren())

   148         children2 = list(xml2.getchildren())

   149         if len(children1) != len(children2):

   150             return False

   151         for child1, child2 in zip(children1, children2):

   152             return equal_xml(child1, child2)

   153     return True        

   154 

   155 

   156 def setup_module():

   157     """ Setup test environment. """

   158     global TEST_PATH, TSRC, OUTPUT

   159     TEST_PATH = path(tempfile.mkdtemp())

   160     OUTPUT = TEST_PATH.joinpath(r"output")

   161     component = TEST_PATH

   162     component.joinpath("group").makedirs()

   163     for path_parts in (("tsrc", "group", "bld.inf"),

   164                        ("tsrc", "group", "test.pkg"),

   165                        ("tsrc", "testmodules", "file1.dll"),

   166                        ("tsrc", "testmodules", "file2.dll"),

   167                        ("tsrc", "data", "file1"),

   168                        ("tsrc", "data", "file2"),

   169                        ("tsrc", "data", "file3"),

   170                        ("tsrc", "data", "mmc", "file4"),

   171                        ("tsrc", "data", "c", "file5"),

   172                        ("tsrc", "conf", "file1.cfg"),

   173                        ("tsrc", "conf", "file2.cfg"),

   174                        ("tsrc", "init", "TestFramework.ini"),

   175                        ("tsrc", "custom", "prepostaction.xml"),

   176                        ("tsrc", "custom", "postpostaction.xml"),

   177                        # These do not have to be under 'tsrc':

   178                        ("tsrc", "output", "images", "file1.fpsx"),

   179                        ("tsrc", "output", "images", "file2.fpsx"),

   180                        ("tsrc", "sis", "file1.sisx"),

   181                        ("tsrc", "sis", "file2.sisx"),

   182                        ("tsrc", "sis", "file3.sisx"),

   183                        ("tsrc", "trace_init", "trace_activation_1.xml")):

   184         filepath = component.joinpath(*path_parts)

   185         if not filepath.parent.exists():

   186             filepath.parent.makedirs()

   187         filepath.touch()

   188         TEST_FILES.setdefault(path_parts[1], []).append(filepath)

   189     TSRC = component.joinpath("tsrc")

   190     filepath = OUTPUT.joinpath("pmd", "pmd_file.pmd")

   191     if not filepath.parent.exists():

   192         filepath.parent.makedirs()

   193     filepath.touch()

   194     TEST_FILES.setdefault("pmd_file", []).append(filepath)

   195     tracing = component.joinpath("tsrc", "trace_init")

   196     root = E('ConfigurationFile')

   197     confs = E("Configurations")

   198     trace_act = SE(confs, "TraceActivation")

   199     conf = SE(trace_act, "Configuration")

   200     conf.set('Name', 'MCU')

   201     mcu = SE(conf, "MCU")

   202     sett = SE(mcu, "settings")

   203     SE(sett, "timestamp")

   204     root.append(confs)

   205     ettree = et.ElementTree(root)

   206     doc = amara.parse(et.tostring(ettree.getroot()))

   207     handle = open(tracing.joinpath("trace_activation_1.xml"), "w")

   208     handle.write(doc.xml(indent="yes"))

   209     handle.close()

   210 #    tracing.writestr("trace_activation_1.xml", doc.xml(indent=u"yes"))

   211     group = component.joinpath("tsrc", "group")

   212     group.joinpath("bld.inf").write_text(

   213         r"""

   214         PRJ_TESTMMPFILES

   215         stif.mmp /* xyz.mmp */ abcd.mmp

   216         /*xyz.mmp*/

   217         eunit.mmp /* xyz.mmp */

   218         both.mmp

   219         ..\sub-component\group\sub-component.mmp

   220         """.replace('\\', os.sep))

   221 

   222     group.joinpath("test.pkg").write_text(

   223         r"""

   224         ;Language - standard language definitions

   225         &EN

   226         

   227         ; standard SIS file header

   228         #{"BTEngTestApp"},(0x04DA27D5),1,0,0

   229         

   230         ;Supports Series 60 v 3.0

   231         (0x101F7961), 0, 0, 0, {"Series60ProductID"}

   232         

   233         ;Localized Vendor Name

   234         %{"BTEngTestApp"}

   235         

   236         ;Unique Vendor name

   237         :"Nokia"

   238         

   239         ; Files to copy

   240         "\tsrc\testmodules\file1.dll"-"c:\sys\bin\file1.dll"

   241         "\tsrc\testmodules\file2.dll"-"c:\sys\bin\file2.dll"

   242         "\tsrc\data\file1"-"e:\sys\bin\file1"

   243         "\tsrc\data\file2"-"e:\sys\bin\file2"

   244         "\tsrc\data\file3"-"e:\sys\bin\file3"

   245         "\tsrc\conf\file1.cfg"-"!:\sys\bin\file1.cfg"

   246         "\tsrc\conf\file2.cfg"-"!:\sys\bin\file2.cfg"

   247         "\tsrc\init\TestFramework.ini"-"!:\sys\bin\TestFramework.ini"

   248         "\tsrc\sis\file1.sisx"-"!:\sys\bin\file1.sisx"

   249         "\tsrc\sis\file2.sisx"-"!:\sys\bin\file2.sisx"

   250         """.replace('\\', os.sep))

   251     group.joinpath("stif.mmp").write_text("LIBRARY stiftestinterface.lib")

   252     group.joinpath("eunit.mmp").write_text("LIBRARY eunit.lib")

   253     group.joinpath("both.mmp").write_text("LIBRARY stiftestinterface.lib eunit.lib")

   254     init = component.joinpath("tsrc", "init")

   255     

   256     init.joinpath("TestFramework.ini").write_text(

   257         r"""

   258 #     - Sets a device reset module's dll name(Reboot).

   259 #        + If Nokia specific reset module is not available or it is not correct one

   260 #          StifHWResetStub module may use as a template for user specific reset

   261 #          module. 

   262 

   263 [Engine_Defaults]

   264 

   265 TestReportMode= FullReport        # Possible values are: 'Empty', 'Summary', 'Environment',

   266                                                                'TestCases' or 'FullReport'

   267 

   268 CreateTestReport= YES            # Possible values: YES or NO

   269 

   270 TestReportFilePath= C:\LOGS\TestFramework\

   271 TestReportFileName= TestReport

   272 

   273 TestReportFormat= TXT            # Possible values: TXT or HTML

   274         

   275         """)

   276 

   277 

   278 def teardown_module():

   279     """ Cleanup environment after testing. """    

   280     def __init__():

   281         path(TEST_PATH).rmtree()

   282 

   283 # CTC related functions    

   284 def check_ctc_write(steps):

   285     """Checks if CTC data is written on the CTC log"""

   286     step = steps.next()

   287     assert step.findtext("./type") == "NonTestExecuteTask"

   288     params = step.findall("./parameters/parameter")

   289     assert params[0].get("value") == "writelocal"

   290     assert params[1].get("value") == path(r"z:\sys\bin\ctcman.exe")

   291     step = steps.next()

   292     assert step.findtext("./type") == "NonTestExecuteTask"

   293     params = step.findall("./parameters/parameter")

   294     assert params[0].get("value") == "writefile"

   295     assert params[1].get("value") == path(r"z:\sys\bin\ctcman.exe")

   296 

   297 def check_ctc_log(steps, testtype=""):

   298     """Fetches CTC Log"""

   299     #For the ctcdata.txt to be published on the ATS network drive

   300     step = steps.next()

   301     assert step.findtext("./type") == "FileDownloadTask"

   302     params = step.findall("./parameters/parameter")

   303     #assert params[0].get("value") == "false"

   304     assert params[0].get("value") == path(r"c:\data\ctc\ctcdata.txt")

   305     if testtype == "withpkgfiles":

   306         assert params[1].get("value") == r"\\10.0.0.1\ctc_helium\builds\drop0\set1\ctcdata"

   307     else:

   308         assert params[1].get("value") == r"\\10.0.0.1\ctc_helium\builds\drop0\set0\ctcdata"

   309     

   310     #For the ctcdata.txt to be published on the build network drive

   311     step = steps.next()

   312     assert step.findtext("./type") == "FileDownloadTask"

   313     params = step.findall("./parameters/parameter")

   314     #assert params[0].get("value") == "true"

   315     assert params[0].get("value") == path(r"c:\data\ctc\ctcdata.txt")

   316 

   317 def check_ctc_start(steps):

   318     """Checks if CTC starts in ATS"""

   319     step = steps.next()

   320     assert step.findtext("./type") == "CreateDirTask"

   321     params = step.findall("./parameters/parameter")

   322     assert params[0].get("value") == path(r"c:\data\ctc")

   323     step = steps.next()

   324     assert step.findtext("./type") == "NonTestExecuteTask"

   325     params = step.findall("./parameters/parameter")

   326     assert params[0].get("value") == path(r"z:\sys\bin\ctcman.exe")   

   327 

   328 def check_fetch_logs(steps, harness="STIF"):

   329     """Checks fetching log directory is created"""

   330     step = steps.next()

   331     assert step.findtext("./type") == "FileDownloadTask"

   332     params = step.findall("./parameters/parameter")

   333     if harness == "STIF":

   334         assert params[0].get("value") == path(r"c:\logs\testframework\*")  

   335     else:

   336         assert params[0].get("value") == path(r"c:\Shared\EUnit\logs\*")

   337 

   338 def check_diamonds_action(action):

   339     """ Testing Diamonds action. """

   340     assert action.findtext("./type") == "DiamondsAction"

   341     assert not action.findall("./parameters/parameter") 

   342 

   343 def check_send_email_action(action, reportemail):

   344     """verifies if sening email option works"""

   345     assert action.findtext("./type") == "EmailAction"

   346     params = action.findall("./parameters/parameter")

   347     assert params[0].get("name") == "subject"

   348     #assert params[0].get("value") == "email subject"

   349     assert params[1].get("name") == "to"

   350     assert params[1].get("value") == reportemail

   351     

   352 def check_ctc_run_process_action(action):

   353     """verifies if CTC run process action works"""

   354     #The parameters for this test are intended to execute on a windows machine

   355     assert action.findtext("./type") == "RunProcessAction"

   356     params = action.findall("./parameters/parameter")

   357     assert params[0].get("name") == "file"

   358     assert params[0].get("value") == "catsctc2html/catsctc2html.exe"

   359     assert params[1].get("name") == "parameters"

   360     assert params[1].get("value") == r"--ctcdata_files=\\10.0.0.1\ctc_helium\1234\drop0\set0\ctcdata --monsym_files=\\10.0.0.1\ctc_helium\1234\mon_syms\1\MON.sym --diamonds_build_id=1234 --drop_id=0 --total_amount_of_drops=1"

   361 

   362 def check_ats_report_action(action, filestore):

   363     """verifies if sening ATS report option works"""

   364     assert action.findtext("./type") == "FileStoreAction"

   365     params = action.findall("./parameters/parameter")

   366     assert params[0].get("name") == "to-folder"

   367     assert params[0].get("value") == filestore

   368     assert params[1].get("name") == "report-type"

   369     assert params[1].get("value") == "ATS_REPORT"

   370     assert params[2].get("name") == "date-format"

   371     assert params[2].get("value") == "yyyyMMdd"

   372     assert params[3].get("name") == "time-format"

   373     assert params[3].get("value") == "HHmmss"

   374 

   375 def check_stif_report_action(action, filestore):

   376     """verifies if sening STIF report option works"""

   377     assert action.findtext("./type") == "FileStoreAction"

   378     params = action.findall("./parameters/parameter")

   379     assert params[0].get("name") == "to-folder"

   380     assert params[0].get("value") == filestore

   381     assert params[1].get("name") == "report-type"

   382     assert params[1].get("value") == "STIF_COMPONENT_REPORT_ALL_CASES"

   383     assert params[2].get("name") == "run-log"

   384     assert params[2].get("value") == "true"

   385     assert params[3].get("name") == "date-format"

   386     assert params[3].get("value") == "yyyyMMdd"

   387     assert params[4].get("name") == "time-format"

   388     assert params[4].get("value") == "HHmmss"

   389 

   390 def check_log_dir(steps):

   391     """ Test the log dir. """

   392     step = steps.next()

   393     assert step.findtext("./type") == "CreateDirTask"

   394 

   395 def check_trace_start(steps, filestore):

   396     """Checks if tracing is started on the ATS"""

   397     step = steps.next()

   398     assert step.findtext("./type") == "trace-start"

   399     params = step.findall("./parameters/parameter")

   400     assert params[0].get("value") == path(r"ATS3Drop\set0\trace_activation\trace_activation_1.xml")

   401     assert params[1].get("value") == "MCU"

   402     assert params[2].get("value") == path(r"ATS3Drop\pmds\pmd_file.pmd")

   403     assert params[3].get("value") == filestore.joinpath("traces", "set0", "tracelog.blx")

   404     assert params[4].get("value") == "60"

   405     assert params[5].get("value") == "yyyyMMdd"

   406     assert params[6].get("value") == "HHmmss"

   407     

   408 def check_trace_end_steps(steps, filestore):

   409     """ Test trace end step. """

   410     step = steps.next()

   411     assert step.findtext("./type") == "trace-stop"

   412     params = step.findall("./parameters/parameter")

   413     assert params[0].get("value") == "60"

   414     step = steps.next()

   415     assert step.findtext("./type") == "trace-convert"

   416     params = step.findall("./parameters/parameter")

   417     assert params[0].get("value") == path(r"ATS3Drop\pmds\pmd_file.pmd")

   418     assert params[1].get("value") == filestore.joinpath("traces", "set0", "tracelog.blx")

   419     assert params[2].get("value") == "60"

   420     assert params[3].get("value") == "yyyyMMdd"

   421     assert params[4].get("value") == "HHmmss"

   422 

   423 class TestTestPlan(mocker.MockerTestCase):

   424     """Creates TestPlan mocker setup"""

   425     def __init__(self, methodName="runTest"):

   426         mocker.MockerTestCase.__init__(self, methodName)  

   427           

   428     def setUp(self):

   429         """ Setup TestTestPlan testsuite. """

   430         opts = Bunch(testrun_name="testrun", harness="STIF", 

   431                      device_type="product", plan_name="ats3_test_plan",

   432                      diamonds_build_url="", report_email="", file_store=path(), test_timeout="60",

   433                      device_hwid="5425", trace_enabled="True", ctc_enabled="True", eunitexerunner_flags="/E S60AppEnv /R Off", 

   434                      multiset_enabled=False, ctc_run_process_params=r"10.0.0.1#x:\ats\drop0.zip#1", monsym_files="", hti="True")

   435         self.atp = ats3.Ats3TestPlan(opts)

   436         self.config_files = TEST_FILES["conf"]

   437         self.data_files = TEST_FILES["data"]

   438         self.engine_ini_file = TEST_FILES["init"][0]

   439         self.image_files = TEST_FILES["output"]

   440         self.sis_files = TEST_FILES["sis"]

   441         self.testmodule_files = TEST_FILES["testmodules"]

   442         self.ctc_enabled = self.atp["ctc_enabled"]

   443         self.custom_dir = "CustomD"

   444         self.eunitexerunner_flags = self.atp["eunitexerunner_flags"]

   445         if self.atp["trace_enabled"].lower() == "true":

   446             self.trace_activation_files = TEST_FILES["trace_init"]    

   447             self.pmd_files = TEST_FILES["pmd_file"]

   448         else:

   449             self.trace_activation_files = []    

   450             self.pmd_files = []

   451         self.test_timeout = self.atp["test_timeout"]

   452         self.eunitexerunner_flags = self.atp["eunitexerunner_flags"]

   453         self.device_hwid = self.atp["device_hwid"]

   454         self.test_harness = self.atp["harness"]

   455         self.src_dst = [("" + os.sep + "tsrc" + os.sep + "testmodules" + os.sep + "file1.dll", "c:\sys\bin\file1.dll", "testmodule"),

   456             ("" + os.sep + "tsrc" + os.sep + "testmodules" + os.sep + "file2.dll", "c:\sys\bin\file2.dll", "testmodule"),

   457             ("" + os.sep + "tsrc" + os.sep + "data" + os.sep + "file1", "e:\sys\bin\file1", "data"),

   458             ("" + os.sep + "tsrc" + os.sep + "data" + os.sep + "file2", "e:\sys\bin\file2", "data"),

   459             ("" + os.sep + "tsrc" + os.sep + "data" + os.sep + "file3", "e:\sys\bin\file3", "data"),

   460             ("" + os.sep + "tsrc" + os.sep + "conf" + os.sep + "file1.cfg", "c:\sys\bin\file1.cfg", "conf"),

   461             ("" + os.sep + "tsrc" + os.sep + "conf" + os.sep + "file2.cfg", "c:\sys\bin\file2.cfg", "conf"),

   462             ("" + os.sep + "tsrc" + os.sep + "init" + os.sep + "TestFramework.ini", "c:\sys\bin\TestFramework.ini", "engine_ini"),

   463             ("" + os.sep + "tsrc" + os.sep + "sis" + os.sep + "file1.sisx", "c:\sys\bin\file1.sisx", ""),

   464             ("" + os.sep + "tsrc" + os.sep + "sis" + os.sep + "file2.sisx", "c:\sys\bin\file2.sisx", ""),]

   465         self.component_path = str(TEST_PATH.joinpath("tsrc", "group"))

   466 

   467     def test_creation(self):

   468         """ Testing creation. """        

   469         assert self.atp["testrun_name"] == "testrun"

   470         assert self.atp["harness"] == "STIF"

   471         assert self.atp["device_type"] == "product"

   472     

   473     def test_insert_set(self):

   474         """ Inserting a set of file. """        

   475         self.atp.insert_set(data_files=self.data_files,

   476                            config_files=self.config_files,

   477                            engine_ini_file=self.engine_ini_file,

   478                            image_files=self.image_files,

   479                            testmodule_files=self.testmodule_files,

   480                            test_timeout=self.test_timeout,

   481                            eunitexerunner_flags=self.eunitexerunner_flags,

   482                            pmd_files=self.pmd_files,                            

   483                            trace_activation_files=self.trace_activation_files,

   484                            component_path=self.component_path)

   485         self.atp.insert_set(image_files=self.image_files,                           

   486                            engine_ini_file=self.engine_ini_file,

   487                            sis_files=self.sis_files,

   488                            test_timeout=self.test_timeout,

   489                            eunitexerunner_flags=self.eunitexerunner_flags,

   490                            pmd_files=self.pmd_files,                            

   491                            trace_activation_files=self.trace_activation_files,

   492                            component_path=self.component_path)

   493         self.atp.insert_set(data_files=self.data_files,

   494                            config_files=self.config_files,

   495                            engine_ini_file=self.engine_ini_file,

   496                            image_files=self.image_files,

   497                            testmodule_files=self.testmodule_files,

   498                            test_timeout=self.test_timeout,

   499                            eunitexerunner_flags=self.eunitexerunner_flags,

   500                            src_dst=self.src_dst,

   501                            pmd_files=self.pmd_files,                            

   502                            trace_activation_files=self.trace_activation_files,

   503                            component_path=self.component_path)

   504         self.atp.insert_set(engine_ini_file=self.engine_ini_file,

   505                            test_timeout=self.test_timeout,

   506                            eunitexerunner_flags=self.eunitexerunner_flags,

   507                            image_files=self.image_files,

   508                            test_harness=self.test_harness,

   509                            src_dst=self.src_dst,

   510                            pmd_files=self.pmd_files,                            

   511                            trace_activation_files=self.trace_activation_files,

   512                            component_path=self.component_path)

   513         self.atp.insert_set(test_timeout=self.test_timeout,      

   514                            eunitexerunner_flags=self.eunitexerunner_flags,               

   515                            image_files=self.image_files,                        

   516                            test_harness=self.test_harness,                      

   517                            src_dst=self.src_dst,                                

   518                            pmd_files=self.pmd_files,                            

   519                            trace_activation_files=self.trace_activation_files,

   520                            component_path=self.component_path)  

   521 

   522         assert self.atp.sets[0] == dict(name="set0",

   523                                        data_files=self.data_files,

   524                                        config_files=self.config_files,

   525                                        engine_ini_file=self.engine_ini_file,

   526                                        image_files=self.image_files,

   527                                        testmodule_files=self.testmodule_files,

   528                                        test_timeout=self.test_timeout,

   529                                        eunitexerunner_flags=self.eunitexerunner_flags,

   530                                        test_harness=self.test_harness,

   531                                        src_dst=[],

   532                                        pmd_files=self.pmd_files,

   533                                        trace_path=self.atp.file_store.joinpath(u"§RUN_NAME§" + os.sep + u"§RUN_START_DATE§_§RUN_START_TIME§", "traces", "set0", "tracelog.blx"),

   534                                        trace_activation_files=self.trace_activation_files,

   535                                        ctc_enabled=self.atp["ctc_enabled"],

   536                                        custom_dir=None,

   537                                        component_path=self.component_path)

   538         assert self.atp.sets[1] == dict(name="set1",

   539                                        image_files=self.image_files,

   540                                        engine_ini_file=self.engine_ini_file,

   541                                        sis_files=self.sis_files,

   542                                        test_timeout=self.test_timeout,

   543                                        eunitexerunner_flags=self.eunitexerunner_flags,

   544                                        test_harness=self.test_harness,

   545                                        pmd_files=self.pmd_files,

   546                                        trace_path=self.atp.file_store.joinpath(u"§RUN_NAME§" + os.sep + u"§RUN_START_DATE§_§RUN_START_TIME§", "traces", "set1", "tracelog.blx"),

   547                                        trace_activation_files=self.trace_activation_files,

   548                                        ctc_enabled=self.atp["ctc_enabled"],

   549                                        custom_dir=None,

   550                                        component_path=self.component_path)

   551 

   552         assert self.atp.sets[2] == dict(name="set2",

   553                                        data_files=self.data_files,

   554                                        config_files=self.config_files,

   555                                        engine_ini_file=self.engine_ini_file,

   556                                        image_files=self.image_files,

   557                                        testmodule_files=self.testmodule_files,

   558                                        test_timeout=self.test_timeout,

   559                                        eunitexerunner_flags=self.eunitexerunner_flags,

   560                                        test_harness=self.test_harness,

   561                                        src_dst=self.src_dst,

   562                                        pmd_files=self.pmd_files,

   563                                        trace_path=self.atp.file_store.joinpath(u"§RUN_NAME§" + os.sep + u"§RUN_START_DATE§_§RUN_START_TIME§", "traces", "set2", "tracelog.blx"),

   564                                        trace_activation_files=self.trace_activation_files,

   565                                        ctc_enabled=self.atp["ctc_enabled"],

   566                                        custom_dir=None,

   567                                        component_path=self.component_path)

   568         assert self.atp.sets[3] == dict(name="set3",

   569                                        data_files=[],

   570                                        config_files=[],

   571                                        engine_ini_file=self.engine_ini_file,

   572                                        image_files=self.image_files,

   573                                        testmodule_files=[],

   574                                        test_timeout=self.test_timeout,

   575                                        eunitexerunner_flags=self.eunitexerunner_flags,

   576                                        test_harness=self.test_harness,

   577                                        src_dst=self.src_dst,

   578                                        pmd_files=self.pmd_files,

   579                                        trace_path=self.atp.file_store.joinpath(u"§RUN_NAME§" + os.sep + u"§RUN_START_DATE§_§RUN_START_TIME§", "traces", "set3", "tracelog.blx"),

   580                                        trace_activation_files=self.trace_activation_files,

   581                                        ctc_enabled=self.atp["ctc_enabled"],

   582                                        custom_dir=None,

   583                                        component_path=self.component_path)

   584 

   585         assert self.atp.sets[4] == dict(name="set4",

   586                                        data_files=[],

   587                                        config_files=[],

   588                                        engine_ini_file=None,

   589                                        image_files=self.image_files,

   590                                        testmodule_files=[],

   591                                        test_timeout=self.test_timeout,

   592                                        eunitexerunner_flags=self.eunitexerunner_flags,

   593                                        test_harness=self.test_harness,

   594                                        src_dst=self.src_dst,

   595                                        pmd_files=self.pmd_files,

   596                                        trace_path=self.atp.file_store.joinpath(u"§RUN_NAME§" + os.sep + u"§RUN_START_DATE§_§RUN_START_TIME§", "traces", "set4", "tracelog.blx"),

   597                                        trace_activation_files=self.trace_activation_files,

   598                                        ctc_enabled=self.atp["ctc_enabled"],

   599                                        custom_dir=None,

   600                                        component_path=self.component_path)

   601         

   602     def test_post_actions_email(self):

   603         """ Testing the send email post-action. """

   604         assert not self.atp.post_actions

   605         receiver = "joe.average@example.com"

   606         self.atp.report_email = receiver

   607         assert len(self.atp.post_actions) == 1

   608         _, items = self.atp.post_actions[0]

   609         items = dict(items)

   610         #assert action == "EmailAction"

   611         assert items["to"] == receiver

   612     

   613     def test_post_actions_ats4_report_only(self):

   614         """ Testing the ats4 report only post-action. """

   615         file_store = path("path/to/files")

   616         self.atp.file_store = file_store

   617         self.atp.harness = "EUNIT"

   618         assert len(self.atp.post_actions) == 2

   619         action, items = self.atp.post_actions[0]

   620         items = dict(items)

   621         assert action == "FileStoreAction"

   622         assert items["report-type"] == "ATS3_REPORT"

   623         assert items["to-folder"].startswith(file_store)

   624         assert items["to-folder"].endswith("ATS3_REPORT")

   625     

   626     def test_post_actions_stif(self):

   627         """ Testing STIF post-actions. """

   628         file_store = path("path/to/files")

   629         self.atp.file_store = file_store

   630         assert len(self.atp.post_actions) == 2

   631         action, items = self.atp.post_actions[1]

   632         items = dict(items)

   633         assert action == "FileStoreAction"

   634         assert items["report-type"] == "STIF_COMPONENT_REPORT_ALL_CASES"

   635         assert items["to-folder"].startswith(file_store)

   636         assert items["to-folder"].endswith("STIF_REPORT")

   637         

   638     def test_post_actions_diamonds(self):

   639         """ Testing Diamonds post-actions. """        

   640         self.atp.diamonds_build_url = "http://diamonds.nmp.company.com/diamonds/builds/1234"

   641         assert len(self.atp.post_actions) == 1

   642         action, items = self.atp.post_actions[0]

   643         assert action == "DiamondsAction"

   644         assert not items

   645 

   646 

   647 class TestComponentParser(mocker.MockerTestCase):

   648     """ Testing the Ats3ComponentParser component parser. """

   649     

   650     def __init__(self, methodName="runTest"):

   651         mocker.MockerTestCase.__init__(self, methodName)

   652     

   653     def assert_paths(self, path1, path2):

   654         """ Checking the path. Validates that path1 and path2 are instance of path and they are equals. """

   655         if not isinstance(path1, path):

   656             path1 = path(path1)

   657         if not isinstance(path2, path):

   658             path2 = path(path2)            

   659         return self.assertEqual(path1.normpath(), path2.normpath())

   660     

   661     def setUp(self):

   662         """ Setting up TestComponentParser testsuite."""

   663         opts = Bunch(build_drive=path(TEST_PATH+os.sep), target_platform="target platform", eunitexerunner_flags="/E S60AppEnv /R Off",

   664                      data_dir=["data"], flash_images=[], sis_files=[], test_timeout="60", harness="STIF", trace_enabled="True", specific_pkg='', hti="True")

   665         self.acp = atc.Ats3ComponentParser(opts)

   666         self.acp.tsrc_dir = TSRC

   667       

   668     def test_detect_dlls(self):

   669         """ Testing dlls detection. """

   670         open(os.path.join(TEST_PATH, 'lib1.dll'), 'w').close()

   671         os.makedirs(os.path.join(TEST_PATH, 'path', 'to', 'another'))

   672         open(os.path.join(TEST_PATH, 'path', 'to', 'another', 'library.dll'), 'w').close()

   673         open(os.path.join(TEST_PATH, 'lib2.dll'), 'w').close()

   674         

   675         # Setup mock objects.

   676         process = self.mocker.mock()

   677         process.communicate()

   678         self.mocker.result(["lib1.dll\npath/to/another/library.dll\nsome/other/file.txt\nlib2.dll\nlib3.dll\n"])

   679         obj = self.mocker.replace("subprocess.Popen")

   680         

   681         if os.sep == '\\': 

   682             raptor_cmd = fileutils.which("sbs.bat")

   683         else:

   684             raptor_cmd = fileutils.which("sbs")

   685         if raptor_cmd:

   686             obj("sbs --what -c target_platform.test", shell=True, stdout=subprocess.PIPE)

   687         else:

   688             obj("abld -w test build target platform", shell=True, stdout=subprocess.PIPE)

   689         self.mocker.result(process)

   690         

   691         self.mocker.replay()

   692         

   693         self.assertEqual([u"lib1.dll", u"library.dll", u"lib2.dll"],

   694                          [dll.name for dll in self.acp.tsrc_dll_files()])

   695 

   696     def test_harness(self):

   697         """ Detect test harness."""

   698         mmp_parser = parser.MmpFileParser()

   699         group = TSRC.joinpath("group")

   700         for harness, mmp in [

   701             ("STIF", group / "stif.mmp"),

   702             ("EUNIT", group / "eunit.mmp"),

   703             ("STIF", group / "both.mmp"),

   704             ]:

   705             self.assertEqual(harness, mmp_parser.get_harness(mmp))

   706 

   707 class TestXMLGeneration(mocker.MockerTestCase):

   708     """Unit tests for the test.xml generation."""

   709     def __init__(self, methodName="runTest"):

   710         mocker.MockerTestCase.__init__(self, methodName)

   711         self.data_files = None

   712         self.config_files = None

   713         self.testmodule_files = None

   714         self.image_files = None

   715         self.engine_ini_file = None

   716         self.report_email = None

   717         self.file_store = None

   718         self.diamonds_build_url = None

   719         self.test_harness = None     

   720         self.src_dst = []

   721         self.trace_enabled = None

   722         self.pmd_files = None

   723         self.trace_activation_files = None

   724         self.ctc_enabled = None

   725         self.eunitexerunner_flags = None

   726         self.test_plan = None

   727         self.gen = None

   728         self.custom_dir = None

   729         self.diamonds_id = None

   730         self.ctc_run_process_params = None

   731         self.drop_count = None

   732         self.ctc_test_data = None

   733         self.ctc_network = None

   734         self.component_path = None

   735         self.drop_id = None

   736 

   737     def generate_xml(self, trace_enabled="False"):

   738         """ Generating the XML. """

   739         def files(*paths):

   740             """creating tsrc path list"""

   741             return [TEST_PATH.joinpath("tsrc", tpath) for tpath in paths]

   742         self.testmodule_files = files("testmodules/file1.dll", "testmodules/file2.dll")

   743         self.data_files = files("data/file1", "data/file2", "data/file3")

   744         self.config_files = files("conf/file1.cfg", "conf/file2.cfg")

   745         self.image_files = files("output/images/file1.fpsx", "output/images/file2.fpsx")

   746         self.engine_ini_file = files("init/TestFramework.ini")[0]

   747         self.report_email = "test.receiver@company.com"

   748         self.file_store = path(r"path/to/reports")

   749         self.diamonds_build_url = "http://diamonds.nmp.company.com/diamonds/builds/1234"

   750         self.test_harness = "STIF"        

   751         self.src_dst = []

   752         self.trace_enabled = trace_enabled

   753         self.pmd_files = TEST_FILES["pmd_file"]

   754         self.trace_activation_files = files("trace_init/trace_activation_1.xml")

   755         self.ctc_enabled = "True"

   756         self.eunitexerunner_flags = "/E S60AppEnv /R Off"

   757         self.custom_dir = "CustomB"

   758         self.component_path = str(TEST_PATH.joinpath("tsrc", "group"))

   759         self.ctc_run_process_params = r"10.0.0.1#x:\ats\drop0.zip#1"

   760         

   761         self.ctc_network = self.ctc_run_process_params.rsplit("#", 2)[0]

   762         self.drop_id = re.findall(".*drop(\d*).zip.*", self.ctc_run_process_params.lower())[0] #extracting int part of drop name

   763         self.drop_count = self.ctc_run_process_params.rsplit("#", 1)[1]

   764         self.diamonds_id = self.diamonds_build_url.rsplit(r"/", 1)[1]

   765 

   766         self.mocker.restore()

   767         test_plan = self.mocker.mock(count=False)

   768         mocker.expect(test_plan["testrun_name"]).result("test")

   769         mocker.expect(test_plan["harness"]).result("STIF")

   770         mocker.expect(test_plan["device_type"]).result("product")

   771         mocker.expect(test_plan["hti"]).result("True")

   772         mocker.expect(test_plan["plan_name"]).result("test plan")

   773         mocker.expect(test_plan["diamonds_build_url"]).result(self.diamonds_build_url)

   774         mocker.expect(test_plan["test_timeout"]).result("60")

   775         mocker.expect(test_plan["eunitexerunner_flags"]).result("/E S60AppEnv /R Off")

   776         mocker.expect(test_plan["device_hwid"]).result("5425")

   777         mocker.expect(test_plan["custom_dir"]).result("custom")

   778         mocker.expect(test_plan.custom_dir).result(path(r"self.custom_dir"))

   779         mocker.expect(test_plan["report_email"]).result(self.report_email)

   780         mocker.expect(test_plan["ctc_run_process_params"]).result(self.ctc_run_process_params)

   781                 

   782         if self.trace_enabled.lower() == "true":

   783             mocker.expect(test_plan["trace_enabled"]).result("True")

   784         else:

   785             mocker.expect(test_plan["trace_enabled"]).result("False")

   786         if self.trace_enabled == "False":

   787             mocker.expect(test_plan.sets).result([

   788                 dict(name="set0", image_files=self.image_files, data_files=self.data_files,

   789                      config_files=self.config_files, testmodule_files=self.testmodule_files,

   790                      engine_ini_file=self.engine_ini_file, test_harness="STIF", src_dst=self.src_dst,

   791                      ctc_enabled=self.ctc_enabled, eunitexerunner_flags=self.eunitexerunner_flags,

   792                      custom_dir=self.custom_dir, component_path=self.component_path, hti="True"),

   793                 dict(name="set1", image_files=self.image_files, data_files=self.data_files,

   794                      config_files=self.config_files, testmodule_files=self.testmodule_files,

   795                      engine_ini_file=self.engine_ini_file,test_harness="STIF", src_dst=self.src_dst,

   796                      ctc_enabled=self.ctc_enabled, eunitexerunner_flags=self.eunitexerunner_flags,

   797                      custom_dir=self.custom_dir, component_path=self.component_path, hti="True"),])

   798         elif self.trace_enabled == "True":

   799             mocker.expect(test_plan.sets).result([

   800                 dict(name="set0", image_files=self.image_files, data_files=self.data_files,

   801                      config_files=self.config_files, testmodule_files=self.testmodule_files,

   802                      engine_ini_file=self.engine_ini_file, test_harness="STIF", src_dst=self.src_dst,

   803                      pmd_files=self.pmd_files, trace_activation_files=self.trace_activation_files,

   804                      trace_path=self.file_store.joinpath("traces", "set0", "tracelog.blx"),

   805                      ctc_enabled=self.ctc_enabled, eunitexerunner_flags=self.eunitexerunner_flags, component_path=self.component_path, custom_dir=None, hti="True"),

   806                 dict(name="set1", image_files=self.image_files, data_files=self.data_files,

   807                      config_files=self.config_files, testmodule_files=self.testmodule_files,

   808                      engine_ini_file=self.engine_ini_file,test_harness="STIF", src_dst=self.src_dst,

   809                      pmd_files=self.pmd_files, trace_activation_files=self.trace_activation_files,

   810                      trace_path=self.file_store.joinpath("traces", "set1", "tracelog.blx"),

   811                      ctc_enabled=self.ctc_enabled, eunitexerunner_flags=self.eunitexerunner_flags, component_path=self.component_path, custom_dir=None, hti="True"),

   812             ])

   813 

   814         ctc_file_name = "catsctc2html/catsctc2html.exe"

   815         ctc_data_path = str(os.path.normpath(r"\\%s\ctc_helium\%s\drop0\set0\ctcdata" % (self.ctc_network, self.diamonds_id)))

   816         mon_files = str(os.path.normpath(r"\\%s\ctc_helium\%s\mon_syms\1\MON.sym" % (self.ctc_network, self.diamonds_id)))

   817         self.ctc_test_data = [ctc_file_name, self.ctc_network, self.drop_id, self.drop_count, self.diamonds_id, ctc_data_path, mon_files] 

   818 

   819         mocker.expect(test_plan.post_actions).result([

   820             ("RunProcessAction", (("file", ctc_file_name ),

   821                                   ("parameters", r"--ctcdata_files=" + ctc_data_path + " --monsym_files=" + mon_files + " --diamonds_build_id=" + self.diamonds_id + " --drop_id=" + self.drop_id + " --total_amount_of_drops=" + self.drop_count ))),

   822             ("EmailAction", (("subject", "Release testing"),

   823                                  ("to", self.report_email))),

   824 #            ("FileStoreAction", (("to-folder", self.file_store),

   825 #                                 ("report-type", "ATS_REPORT"),

   826 #                                 ("date-format", "yyyyMMdd"),

   827 #                                 ("time-format", "HHmmss"))),

   828 #            ("FileStoreAction", (("to-folder", self.file_store),

   829 #                                 ("report-type", "STIF_COMPONENT_REPORT_ALL_CASES"),

   830 #                                 ("run-log", "true"),

   831 #                                 ("date-format", "yyyyMMdd"),

   832 #                                 ("time-format", "HHmmss"))),

   833             ("DiamondsAction", ())])

   834         self.mocker.replay()

   835         self.test_plan = test_plan

   836         self.gen = adg.Ats3TemplateTestDropGenerator()

   837         return self.gen.generate_xml(test_plan)

   838 

   839     def test_basic_structure(self):

   840         """ Check that the overall test.xml structure is valid. """

   841         xml = self.generate_xml()

   842         # Check basics.

   843 #        assert xml.find(".").tag == "test"

   844 #        assert xml.find("./name").text == "test"

   845 #        assert xml.find("./buildid").text == self.diamonds_build_url

   846 #        assert xml.find("./target").tag

   847 #        assert xml.find("./target/device").tag

   848 #        harness, type_, device_hwid = xml.findall("./target/device/property")

   849 #        assert harness.get("value") == "STIF"

   850 #        assert type_.get("value") == "product"

   851 #        assert device_hwid.get("value") == "5425"

   852 #        

   853 #        # Check generation of the test plan.

   854 #        assert xml.find("./plan").get("name") == "test Plan"

   855 #        assert xml.find("./plan/session").tag 

   856 #        sets = xml.findall("./execution")

   857 #        assert len(sets) == 2

   858 #        assert sets[0].get("name") == "set0-"+str(TEST_PATH.joinpath("tsrc", "group"))

   859 #        assert sets[0].find("./target/device").tag

   860 

   861     def test_set_structure(self):

   862         """ Check that a <set> element's structure is valid. """

   863         xml = self.generate_xml()

   864         tstset = xml.find("./execution")

   865         assert tstset.tag

   866         

   867     def test_case_flash_elems(self):

   868         """ Test case flash elems. """

   869         xml = self.generate_xml()

   870         found = False

   871         for case in xml.findall(".//task"):

   872             if case.find('type').text == 'FlashTask':

   873                 found = True

   874                 flashes = case.findall("./parameters/parameter")

   875                 assert len(flashes) == len(self.image_files)

   876                 for i, flash_file in enumerate(self.image_files):

   877                     assert flashes[i].get("name") == "image-" + str(i + 1)

   878                     assert flashes[i].get("value") == "ATS3Drop\\images\\" + flash_file.name

   879         assert found

   880         

   881     def test_case_steps(self):

   882         """ Test case steps. """

   883         xml = self.generate_xml()

   884         steps = iter(xml.findall(".//task"))

   885         steps.next() # Flash images

   886         check_ctc_start(steps)

   887         check_log_dir(steps)

   888         self.check_install_data(steps)

   889         self.check_install_configuration(steps)

   890         self.check_install_tmodules(steps)

   891         self.check_install_engine_ini(steps)

   892         self.check_run_cases(steps)

   893         check_ctc_write(steps)

   894         check_ctc_log(steps)

   895         check_fetch_logs(steps)

   896 

   897     def check_install_data(self, steps):

   898         """ Test install data. """

   899         for filename in self.data_files:

   900             step = steps.next()

   901             assert step.findtext("./type") == "FileUploadTask"

   902             params = step.findall("./parameters/parameter")            

   903             src = params[0].get("value")

   904             assert ntpath.basename(src) == ntpath.basename(filename)

   905             assert ntpath.dirname(src) == "ATS3Drop\\set0\\data"

   906             dst = params[1].get("value")

   907             assert ntpath.basename(dst) == ntpath.basename(filename)

   908             assert ntpath.dirname(dst) == r"e:\testing\data"

   909     

   910     def check_install_configuration(self, steps):

   911         """ Test install configuration. """

   912         for filepath in self.config_files:

   913             step = steps.next()

   914             assert step.findtext("./type") == "FileUploadTask"

   915             params = step.findall("./parameters/parameter")

   916             assert params[0].get("value") == "ATS3Drop\\set0\\conf\\" + ntpath.basename(filepath)

   917             assert params[1].get("value") == "e:\\testing\\conf\\" + ntpath.basename(filepath)

   918 

   919     def check_install_tmodules(self, steps):

   920         """ Test install tmodules. """

   921         for filepath in self.testmodule_files:

   922             step = steps.next()

   923             assert step.findtext("./type") == "FileUploadTask"

   924             params = step.findall("./parameters/parameter")

   925             assert params[0].get("value") == "ATS3Drop\\set0\\testmodules\\" + ntpath.basename(filepath)

   926             assert params[1].get("value") == "c:\\sys\\bin\\" + ntpath.basename(filepath)

   927     

   928     def check_install_engine_ini(self, steps):

   929         """ Test install engine ini. """

   930         filepath = self.engine_ini_file

   931         step = steps.next()

   932         assert step.findtext("./type") == "FileUploadTask"

   933         params = step.findall("./parameters/parameter")

   934         assert params[0].get("value") == "ATS3Drop\\set0\\init\\" + ntpath.basename(filepath)

   935         assert params[1].get("value") == "c:\\testframework\\" + ntpath.basename(filepath)

   936     

   937     def check_run_cases(self, steps):

   938         """ Test run cases. """

   939         step = steps.next()

   940         assert step.findtext("./type") == "StifRunCasesTask"

   941         params = step.findall("./parameters/parameter")

   942         assert params[0].get("value") == "*"

   943         assert params[1].get("value") == "60"

   944         assert params[2].get("value") == "c:\\testframework\\" + ntpath.basename(self.engine_ini_file)

   945 

   946     def test_steps_trace_enabled(self):

   947         """ Test steps trace enabled. """

   948         xml = self.generate_xml(trace_enabled="True")

   949         steps = iter(xml.findall(".//task"))

   950         steps.next() # Flash images

   951         check_ctc_start(steps)

   952         check_log_dir(steps)

   953         self.check_install_data(steps)

   954         self.check_install_configuration(steps)

   955         self.check_install_tmodules(steps)

   956         self.check_install_engine_ini(steps)

   957         #check_trace_start(steps, self.file_store)

   958         self.check_run_cases(steps)

   959         #check_trace_end_steps(steps, self.file_store)

   960         check_ctc_write(steps)

   961         check_ctc_log(steps)

   962         check_fetch_logs(steps) 

   963     

   964     def test_post_actions(self):

   965         """ Post actions are inserted into XML. """

   966         xml = self.generate_xml()        

   967         post_actions = xml.findall(".//action")

   968         check_ctc_run_process_action(post_actions[0])

   969         check_send_email_action(post_actions[1], self.report_email)

   970         #check_ats_report_action(post_actions[2], self.file_store)

   971         #check_stif_report_action(post_actions[3], self.file_store)

   972         check_diamonds_action(post_actions[2])

   973     

   974 #    def test_files(self):

   975 #        """ Testing files. """

   976 #        xml = self.generate_xml()

   977 #        files = iter(xml.findall("./files/file"))

   978 #        assert files.next().text == r"ATS3Drop/images/file1.fpsx"

   979 #        assert files.next().text == r"ATS3Drop/images/file2.fpsx"

   980 #        assert files.next().text == r"ATS3Drop/set0/data/file1"

   981 #        assert files.next().text == r"ATS3Drop/set0/data/file2"

   982 #        assert files.next().text == r"ATS3Drop/set0/data/file3"

   983 #        assert files.next().text == r"ATS3Drop/set0/conf/file1.cfg"

   984 #        assert files.next().text == r"ATS3Drop/set0/conf/file2.cfg"

   985 #        assert files.next().text == r"ATS3Drop/set0/testmodules/file1.dll"

   986 #        assert files.next().text == r"ATS3Drop/set0/testmodules/file2.dll"

   987 #        assert files.next().text == r"ATS3Drop/set0/init/TestFramework.ini"        

   988 #        assert files.next().text == r"ATS3Drop/set1/data/file1"

   989 #        assert files.next().text == r"ATS3Drop/set1/data/file2"

   990 #        assert files.next().text == r"ATS3Drop/set1/data/file3"

   991 #        assert files.next().text == r"ATS3Drop/set1/conf/file1.cfg"

   992 #        assert files.next().text == r"ATS3Drop/set1/conf/file2.cfg"

   993 #        assert files.next().text == r"ATS3Drop/set1/testmodules/file1.dll"

   994 #        assert files.next().text == r"ATS3Drop/set1/testmodules/file2.dll"

   995 #        assert files.next().text == r"ATS3Drop/set1/init/TestFramework.ini"        

   996 #        self.assertRaises(StopIteration, files.next)

   997 #        xml = self.generate_xml(trace_enabled="True")

   998 #        files = iter(xml.findall("./files/file"))

   999 #        assert files.next().text == r"ATS3Drop/images/file1.fpsx"

  1000 #        assert files.next().text == r"ATS3Drop/images/file2.fpsx"

  1001 #        assert files.next().text == r"ATS3Drop/pmds/pmd_file.pmd"

  1002 #        assert files.next().text == r"ATS3Drop/set0/data/file1"

  1003 #        assert files.next().text == r"ATS3Drop/set0/data/file2"

  1004 #        assert files.next().text == r"ATS3Drop/set0/data/file3"

  1005 #        assert files.next().text == r"ATS3Drop/set0/conf/file1.cfg"

  1006 #        assert files.next().text == r"ATS3Drop/set0/conf/file2.cfg"

  1007 #        assert files.next().text == r"ATS3Drop/set0/testmodules/file1.dll"

  1008 #        assert files.next().text == r"ATS3Drop/set0/testmodules/file2.dll"

  1009 #        assert files.next().text == r"ATS3Drop/set0/init/TestFramework.ini"

  1010 #        assert files.next().text == r"ATS3Drop/set0/trace_init/trace_activation_1.xml"

  1011 #        assert files.next().text == r"ATS3Drop/set1/data/file1"

  1012 #        assert files.next().text == r"ATS3Drop/set1/data/file2"

  1013 #        assert files.next().text == r"ATS3Drop/set1/data/file3"

  1014 #        assert files.next().text == r"ATS3Drop/set1/conf/file1.cfg"

  1015 #        assert files.next().text == r"ATS3Drop/set1/conf/file2.cfg"

  1016 #        assert files.next().text == r"ATS3Drop/set1/testmodules/file1.dll"

  1017 #        assert files.next().text == r"ATS3Drop/set1/testmodules/file2.dll"

  1018 #        assert files.next().text == r"ATS3Drop/set1/init/TestFramework.ini"

  1019 #        assert files.next().text == r"ATS3Drop/set1/trace_init/trace_activation_1.xml"        

  1020 #        self.assertRaises(StopIteration, files.next)

  1021         

  1022     def test_generate_drop(self):

  1023         """ Manifest for ATS3Drop directory structure is generated. """

  1024         xml = self.generate_xml()

  1025         strbuffer = StringIO()

  1026         

  1027         self.gen.generate_drop(self.test_plan, xml, strbuffer)

  1028         zfile = zipfile.ZipFile(strbuffer, "r")

  1029         try:

  1030             contents = sorted(path(tpath).normpath() for tpath in zfile.namelist())

  1031             expected = sorted(path(tpath).normpath()

  1032                            for tpath in [r"ATS3Drop" + os.sep + "set0" + os.sep + "conf" + os.sep + "file1.cfg",

  1033                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "conf" + os.sep + "file2.cfg",

  1034                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file1",

  1035                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file2",

  1036                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file3",

  1037                                      r"ATS3Drop" + os.sep + "images" + os.sep + "file1.fpsx",

  1038                                      r"ATS3Drop" + os.sep + "images" + os.sep + "file2.fpsx",

  1039                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "init" + os.sep + "TestFramework.ini",

  1040                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "testmodules" + os.sep + "file1.dll",

  1041                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "testmodules" + os.sep + "file2.dll",

  1042                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "conf" + os.sep + "file1.cfg",

  1043                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "conf" + os.sep + "file2.cfg",

  1044                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file1",

  1045                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file2",

  1046                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file3",

  1047                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "init" + os.sep + "TestFramework.ini",

  1048                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "testmodules" + os.sep + "file1.dll",

  1049                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "testmodules" + os.sep + "file2.dll",

  1050                                      r"test.xml"])

  1051             diff = difflib.context_diff(expected, contents)

  1052             assert contents == expected, "\n".join(diff)

  1053         finally:

  1054             zfile.close()

  1055 

  1056     def test_generate_drop_trace (self):

  1057         "Manifest for ATS3Drop directory structure is generated when trace enabled."

  1058         xml = self.generate_xml(trace_enabled="True")

  1059         strbuffer = StringIO()

  1060         

  1061         self.gen.generate_drop(self.test_plan, xml, strbuffer)

  1062         zfile = zipfile.ZipFile(strbuffer, "r")

  1063         try:

  1064             contents = sorted(path(tpath).normpath() for tpath in zfile.namelist())

  1065             expected = sorted(path(tpath).normpath()

  1066                            for tpath in [r"ATS3Drop" + os.sep + "set0" + os.sep + "conf" + os.sep + "file1.cfg",

  1067                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "conf" + os.sep + "file2.cfg",

  1068                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file1",

  1069                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file2",

  1070                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "data" + os.sep + "file3",

  1071                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "trace_init" + os.sep + "trace_activation_1.xml",

  1072                                      r"ATS3Drop" + os.sep + "images" + os.sep + "file1.fpsx",

  1073                                      r"ATS3Drop" + os.sep + "images" + os.sep + "file2.fpsx",

  1074                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "init" + os.sep + "TestFramework.ini",

  1075                                      r"ATS3Drop" + os.sep + "pmds" + os.sep + "pmd_file.pmd",

  1076                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "testmodules" + os.sep + "file1.dll",

  1077                                      r"ATS3Drop" + os.sep + "set0" + os.sep + "testmodules" + os.sep + "file2.dll",

  1078                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "conf" + os.sep + "file1.cfg",

  1079                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "conf" + os.sep + "file2.cfg",

  1080                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file1",

  1081                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file2",

  1082                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "data" + os.sep + "file3",

  1083                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "trace_init" + os.sep + "trace_activation_1.xml",

  1084                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "init" + os.sep + "TestFramework.ini",

  1085                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "testmodules" + os.sep + "file1.dll",

  1086                                      r"ATS3Drop" + os.sep + "set1" + os.sep + "testmodules" + os.sep + "file2.dll",

  1087                                      r"test.xml"])

  1088             diff = difflib.context_diff(expected, contents)

  1089             assert contents == expected, "\n".join(diff)

  1090         finally:

  1091             zfile.close()

  1092 

  1093 

  1094 class TestXMLGenerationWithPKG(mocker.MockerTestCase):

  1095     """

  1096     Unit tests for the test.xml generation.

  1097     """

  1098     def __init__(self, methodName="runTest"):

  1099         mocker.MockerTestCase.__init__(self, methodName)

  1100         self.src_dst1 = []

  1101         self.data_files = None

  1102         self.config_files = None

  1103         self.testmodule_files = None

  1104         self.image_files = None

  1105         self.engine_ini_file = None

  1106         self.report_email = None

  1107         self.file_store = None

  1108         self.diamonds_build_url = None

  1109         self.trace_enabled = None

  1110         self.pmd_files = None

  1111         self.trace_activation_files = None

  1112         self.ctc_enabled = None

  1113         self.eunitexerunner_flags = None

  1114         self.test_plan = None

  1115         self.gen = None

  1116         self.src_dst0 = []

  1117         self.custom_dir = None

  1118         self.custom_files = None

  1119         self.component_path = None

  1120         self.ctc_run_process_params = None

  1121         

  1122     def generate_xml(self, harness, trace_enabled="False"):

  1123         """Generates XML"""

  1124         def files(*paths):

  1125             """generates paths for the files"""

  1126             return [TEST_PATH.joinpath("tsrc", tpath) for tpath in paths]

  1127 

  1128         self.src_dst1 = []

  1129         self.data_files = files("data/file1", "data/file2", "data/file3")

  1130         self.config_files = files("conf/file1.cfg", "conf/file2.cfg")

  1131         self.testmodule_files = files("testmodules/file1.dll", "testmodules/file2.dll")

  1132         self.image_files = files("output/images/file1.fpsx", "output/images/file2.fpsx")

  1133         self.engine_ini_file = files("init/TestFramework.ini")[0]

  1134         self.report_email = "test.receiver@company.com"