FieldValueTests.py

Go to the documentation of this file.

#
# Copyright 2009, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
 
 
 
 
# -- system imports ----------------------------------------------------------------------------{{{-
import os
import xml.etree.cElementTree as etree
 
import sys
 
from random import shuffle
from datetime import datetime
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
import mevis
 
from TestSupport.ChangeSet import ChangeSet
# ----------------------------------------------------------------------------------------------}}}-
 
# -- class FieldValueTestCaseIterator ----------------------------------------------------------{{{-
 
class FieldValueTestCaseIterator :
  # -- member variables ------------------------------------------------------------------------{{{-
  
  __filename = None
 
  
  __fieldValueTestCaseSet = None
  
  __testCaseList = None
  
  __testCase = None
  
  __index = None
 
  
  __changeSet = None
 
  
  __running = None
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __init__ ----------------------------------------------------------------------------{{{-
  
  def __init__ (self, ctx, filename, testRunName=None, randomOrder=False):
    self.__filename = filename
    self.__fieldValueTestCaseSet = FieldValueTestCaseSet(ctx)
 
    self.__index = 0
    self.__running = True
    self.__statusString = ""
 
    # Set test run name to given value or a timestamp.
    self.__testRunName = testRunName if testRunName else str(datetime.now())
 
    self.__changeSet = ChangeSet(ctx)
 
    if not self.__fieldValueTestCaseSet.load(self.__filename):
      self.__running = False
      self.__testCaseList = []
    else:
      # Build up the list of available test cases.
      self.__testCaseList = sorted(self.__fieldValueTestCaseSet.getList())
      if randomOrder:
        shuffle(self.__testCaseList)
      self.__setTestCase()
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getCurrentIndex --------------------------------------------------------------------------{{{-
  
  def getCurrentIndex (self):
    return self.__index
  # --------------------------------------------------------------------------------------------}}}-
  
  # -- def getStatusString --------------------------------------------------------------------------{{{-
  
  def getStatusString (self):
    return self.__statusString
  # --------------------------------------------------------------------------------------------}}}-
  
  # -- def getCurrentCaseName --------------------------------------------------------------------------{{{-
  
  def getCurrentCaseName (self):
    return self.__testCaseList[self.__index]
  # --------------------------------------------------------------------------------------------}}}-
  
  # -- def getIndex --------------------------------------------------------------------------{{{-
  
  def getNumCases (self):
    return len(self.__testCaseList)
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def isFinished --------------------------------------------------------------------------{{{-
  
  def isFinished (self):
    return not self.__running
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def next --------------------------------------------------------------------------------{{{-
  
  def next (self, verbose=False, saveEachCase = True):
    failedFieldList = []
    if not self.__running or not self.__testCase.verifyExpectedResults(failedFieldList=failedFieldList, findAll=True, verbose=verbose):
      return False, failedFieldList
    self.__testCase.saveResults(self.__testRunName, overwrite=True)
    self.__index += 1
    if self.__index < len(self.__testCaseList):
      if saveEachCase:
        # save result after each step. that way, in case the application crashes, results wont't be lost
        self.__fieldValueTestCaseSet.save(self.__filename)
      self.__setTestCase()
    else:
      self.__index = -1
      self.__running = False
      self.__fieldValueTestCaseSet.save(self.__filename)
      self.__statusString = "finished"
    return True, []
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def finish --------------------------------------------------------------------------------{{{-
  
  def finish (self, verbose = False):
    if not self.__running:
      return False
    if verbose:
        print("finishing run")
    self.__index = -1
    self.__running = False
    self.__fieldValueTestCaseSet.save(self.__filename)
    self.__statusString = "finished"
    return True
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def prev --------------------------------------------------------------------------------{{{-
  
  def prev (self, verbose = False):
    if not self.__running or self.__index == 0:
      return False
    if verbose:
        print("going to prev test case")
    self.__index -= 1
    self.__setTestCase()
    return True
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def goToCaseWithId ----------------------------------------------------------------------{{{-
  
  def goToCaseWithId (self, id, verbose = False):
    if not self.__running or id < 0 or id >= self.getNumCases():
      return False
    if verbose:
        print("going to case with id ", id)
    self.__index = id
    self.__setTestCase()
    return True
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __setTestCase -----------------------------------------------------------------------{{{-
  
  def __setTestCase (self):
    self.__changeSet.revert()
    self.__testCase = self.__fieldValueTestCaseSet.get(self.__testCaseList[self.__index])
    self.__testCase.applyParameterization(self.__changeSet)
    self.__statusString = "%d/%d (%s)" % (self.getCurrentIndex() + 1, self.getNumCases(), self.getCurrentCaseName())
    
  # --------------------------------------------------------------------------------------------}}}-
# ----------------------------------------------------------------------------------------------}}}-
 
# -- class FieldValueTestCaseSet ---------------------------------------------------------------{{{-
 
class FieldValueTestCaseSet :
  # -- member variables ------------------------------------------------------------------------{{{-
  
  __ctx = None
 
  
  __xmlTree = None
  
  __xmlRoot = None
 
  
  __fieldValueTestCaseDict = None
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __init__ ----------------------------------------------------------------------------{{{-
  
  def __init__ (self, context):
    self.__fieldValueTestCaseDict = {}
 
    self.__ctx = context
 
    self.__xmlRoot = etree.Element('FieldValueTestCaseSet')
    self.__xmlTree = etree.ElementTree(self.__xmlRoot)
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def load --------------------------------------------------------------------------------{{{-
  
  def load (self, filename):
    retVal = True
    if len(self.__fieldValueTestCaseDict) != 0:
      mevis.MLAB.logError("There are already field-value test cases in this set. Loading not supported in this case!")
      retVal = False
    # Verify file with given filename exists.
    elif not os.path.isfile(filename):
      mevis.MLAB.logError("File %s does not exist." % (filename))
      retVal = False
    else:
      # Load file and try to verify the file's content.
      xmlTree = etree.parse(filename)
      xmlRoot = xmlTree.getroot()
      if not self.__verify(xmlRoot):
        retVal = False
      else:
        self.__xmlTree = xmlTree
        self.__xmlRoot = xmlRoot
 
        for node in self.__xmlRoot.findall('FieldValueTestCase'):
          testCaseName = node.get('name')
          self.__fieldValueTestCaseDict[testCaseName] = None
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def save --------------------------------------------------------------------------------{{{-
  
  def save (self, filename):
    # Update the XML datastructure from the field-value test case objects.
    for node in self.__xmlRoot.findall('FieldValueTestCase'):
      name = node.get('name')
      if self.__fieldValueTestCaseDict[name]:
        self.__fieldValueTestCaseDict[name].save(node)
    self.__xmlTree.write(filename)
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getList -----------------------------------------------------------------------------{{{-
  
  def getList (self):
    return list(self.__fieldValueTestCaseDict.keys())
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def add ---------------------------------------------------------------------------------{{{-
  
  def add (self, fieldValueTestCase):
    retVal = True
    name = fieldValueTestCase.getName()
    if name in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("Test with name %s already known!" % (name))
      retVal = False
    else:
      self.__fieldValueTestCaseDict[name] = fieldValueTestCase
      self.__xmlRoot.append(fieldValueTestCase.save())
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def copy --------------------------------------------------------------------------------{{{-
  
  def copy (self, source, destination):
    retVal = True
    if not source in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("FieldValueTestCase with name %s not known!" % (source))
      retVal = False
    else:
      node = self.__getFieldValueTestCaseNode(source)
      if node is None:
        retVal = False
      else:
        # Save source to be sure to copy the current state. If the source has
        # not be used after loading there is no FieldValueTestCase object in
        # the dict and then nothing must be saved.
        if not self.__fieldValueTestCaseDict[source] is None:
          self.__fieldValueTestCaseDict[source].save(node)
        # Add new node to the internal data structures.
        retVal = self.add(FieldValueTestCase(destination, self.__ctx, node))
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def remove ------------------------------------------------------------------------------{{{-
  
  def remove (self, name):
    retVal = True
    if not name in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("FieldValueTestCase with name %s not known!" % (name))
      retVal = False
    else:
      node = self.__getFieldValueTestCaseNode(name)
      if node is None:
        retVal = False
      else:
        self.__xmlRoot.remove(node)
        del self.__fieldValueTestCaseDict[name]
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def rename ------------------------------------------------------------------------------{{{-
  
  def rename (self, name, newName):
    retVal = True
    if not name in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("FieldValueTestCase with name %s not known!" % (name))
      retVal = False
    elif newName in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("FieldValueTestCase with name %s already exists!" % (newName))
      retVal = False
    else:
      node = self.__getFieldValueTestCaseNode(name)
      if node is None:
        # Failed to find the given field-value test case in the XML data structure.
        retVal = False
      else:
        # Set node name in the XML data structure.
        node.set('name', newName)
        # If field-value test case is loaded set name there and rename it in
        # the dictionary with all field-value test cases.
        fieldValueTestCase = self.__fieldValueTestCaseDict[name]
        if not fieldValueTestCase is None:
          fieldValueTestCase.setName(newName)
        self.__fieldValueTestCaseDict[newName] = fieldValueTestCase
        del self.__fieldValueTestCaseDict[name]
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def get ---------------------------------------------------------------------------------{{{-
  
  def get (self, name):
    fieldValueTestCase = None
    if name not in self.__fieldValueTestCaseDict:
      mevis.MLAB.logError("FieldValueTestCase with name %s not found!" % (name))
    else:
      # If the field-value test case has not yet been created: do that.
      if not self.__fieldValueTestCaseDict[name]:
        node = self.__getFieldValueTestCaseNode(name)
        if not node is None:
          self.__fieldValueTestCaseDict[name] = FieldValueTestCase(name, self.__ctx, node)
      fieldValueTestCase = self.__fieldValueTestCaseDict[name]
    return fieldValueTestCase
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __verify ----------------------------------------------------------------------------{{{-
  def __verify (self, xmlRoot):
    if not xmlRoot.tag == "FieldValueTestCaseSet":
      return False
 
    for fieldValueTestCaseNode in xmlRoot:
      if not fieldValueTestCaseNode.tag == "FieldValueTestCase":
        mevis.MLAB.logError("Only FieldValueTestCase nodes allowed.")
        return False
      settingsNode = fieldValueTestCaseNode.find("Settings")
      resultsNode = fieldValueTestCaseNode.find("Results")
      if settingsNode is None or resultsNode is None:
        mevis.MLAB.logError("Settings and Results node must be defined.")
        return False
      if len(fieldValueTestCaseNode) != 2:
        mevis.MLAB.logError("Wrong number of children (%d instead of 2)." % (len(fieldValueTestCaseNode)))
        return False
      flList = [False, False, False]
      for fieldListNode in settingsNode:
        if fieldListNode.tag == "FieldValueList":
          name = fieldListNode.get("name")
          if name == "Parameterization" and not flList[0]:
            flList[0] = True
          elif name == "ExpectedResults" and not flList[1]:
            flList[1] = True
          else:
            mevis.MLAB.logError("Only FieldValueLists with name Parameterization or ExpectedResults allowed here.")
            return False
        elif fieldListNode.tag == "FieldList":
          name = fieldListNode.get("name")
          if name == "ResultsToSave" and not flList[2]:
            flList[2] = True
          else:
            mevis.MLAB.logError("Only FieldLists with name ResultsToSave allowed here (not %s)." % (name))
            return False
        else:
          mevis.MLAB.logError("Only FieldValueList and FieldList allowed here (not %s)." % (fieldListNode.tag))
          return False
        for child in fieldListNode:
          if child.tag != "Field":
            mevis.MLAB.logError("There must only be nodes of type Field.")
            return False
          if not (child.get("module") != None and child.get("field") != None and child.get("type") != None):
            mevis.MLAB.logError("Each field must have information on the module, field and type.")
            return False
      if not flList[0] or not flList[1] or not flList[2]:
        mevis.MLAB.logError("There must be FieldValueLists (with name Parameterization and ExpectedResults) and a FieldList (with name ResultsToSave).")
        return False
      for fieldListNode in resultsNode:
        pass
    return True
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __getFieldValueTestCaseNode ---------------------------------------------------------{{{-
  
  def __getFieldValueTestCaseNode (self, name):
    for node in self.__xmlRoot.findall('FieldValueTestCase'):
      if node.get('name') == name:
        return node
    mevis.MLAB.logError("FieldValueTestCase %s not found in XML data-structure!" % (name))
    return None
  # --------------------------------------------------------------------------------------------}}}-
# ----------------------------------------------------------------------------------------------}}}-
 
# -- class FieldValueTestCase -----------------------------------------------------------------{{{-
 
class FieldValueTestCase :
  # -- member variables ------------------------------------------------------------------------{{{-
  
  __name               = None
  
  __ctx                = None
 
  
  __fieldValueListDict = None
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- class FieldListBase ---------------------------------------------------------------------{{{-
  
  class FieldListBase (list):
    # -- member variables ----------------------------------------------------------------------{{{-
    
    _type = None
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def __init__ --------------------------------------------------------------------------{{{-
    
    def __init__ (self, name):
      self.__name = name
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def add -------------------------------------------------------------------------------{{{-
    
    def add (self, fieldInfo, index=None):
      retVal = index
      if not index is None:
        if index < 0:
          index = 0
        if index > len(self):
          index = len(self)
      else:
        index = len(self)
      return self._add(index, fieldInfo)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def remove ----------------------------------------------------------------------------{{{-
    
    def remove (self, index):
      retVal = True
      if index >= 0 and index < len(self):
        del self[index]
      else:
        retVal = False
      return retVal
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def swap ------------------------------------------------------------------------------{{{-
    
    def swap (self, indexA, indexB):
      retVal = True
      if indexA>=0 and indexA<len(self) and indexB>=0 and indexB<len(self) and indexA!=indexB:
        tmp = self[indexA]
        self[indexA] = self[indexB]
        self[indexB] = tmp
      else:
        retVal = False
      return retVal
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def load ------------------------------------------------------------------------------{{{-
    
    def load (self, xmlNode):
      for fieldNode in xmlNode.findall('Field'):
        self.append(self._loadField(fieldNode))
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def save ------------------------------------------------------------------------------{{{-
    
    def save (self):
      xmlNode = etree.Element(self._type, name=self.__name)
      for fieldInfo in self:
        self._saveField(fieldInfo, xmlNode)
      return xmlNode
    # ------------------------------------------------------------------------------------------}}}-
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- class FieldList -------------------------------------------------------------------------{{{-
  
  class FieldList (FieldListBase):
    # -- def __init__ --------------------------------------------------------------------------{{{-
    
    def __init__ (self, name):
      self._type_type = 'FieldList'
      FieldValueTestCase.FieldListBase.__init__(self, name)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def update ----------------------------------------------------------------------------{{{-
    
    def update (self, index, fieldInfo):
      return
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _add ------------------------------------------------------------------------------{{{-
    
    def _add (self, index, fieldInfo):
      self.insert(index, fieldInfo[0:3])
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _loadField ------------------------------------------------------------------------{{{-
    
    def _loadField (self, xmlNode):
      return (xmlNode.get("module"), xmlNode.get("field"), xmlNode.get("type"))
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _saveField ------------------------------------------------------------------------{{{-
    
    def _saveField (self, fieldInfo, xmlNode):
      etree.SubElement(xmlNode, 'Field', module=fieldInfo[0], field=fieldInfo[1], type=fieldInfo[2])
    # ------------------------------------------------------------------------------------------}}}-
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- class FieldValueList --------------------------------------------------------------------{{{-
  
  class FieldValueList (FieldListBase):
    # -- def __init__ --------------------------------------------------------------------------{{{-
    def __init__ (self, name):
      self._type_type = 'FieldValueList'
      FieldValueTestCase.FieldListBase.__init__(self, name)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def update ----------------------------------------------------------------------------{{{-
    
    def update (self, index, fieldInfo):
      fieldType = fieldInfo[2]
      fieldValue = self.__convertValue(fieldInfo[3], fieldType)
      self[index] = (fieldInfo[0], fieldInfo[1], fieldType, fieldValue)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _add ------------------------------------------------------------------------------{{{-
    
    def _add (self, index, fieldInfo):
      self.insert(index, fieldInfo)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _loadField ------------------------------------------------------------------------{{{-
    
    def _loadField (self, xmlNode):
      fieldType = xmlNode.get("type")
      fieldValue = self.__convertValue(xmlNode.text, fieldType)
      return (xmlNode.get("module"), xmlNode.get("field"), fieldType, fieldValue)
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def _saveField ------------------------------------------------------------------------{{{-
    
    def _saveField (self, fieldInfo, xmlNode):
      if fieldInfo[2] not in ('Trigger'):
        etree.SubElement(xmlNode, 'Field', module=fieldInfo[0], field=fieldInfo[1], type=fieldInfo[2]).text = str(fieldInfo[3])
      else:
        etree.SubElement(xmlNode, 'Field', module=fieldInfo[0], field=fieldInfo[1], type=fieldInfo[2])
    # ------------------------------------------------------------------------------------------}}}-
 
    # -- def __convertValue ----------------------------------------------------------------------{{{-
    
    def __convertValue (self, value, type):
      if   type == "Integer":
        value = int(value)
      elif type in ('Float', 'Double'):
        value = float(value)
      elif 'Vector' in type:
        value = tuple([float(x) for x in value[1:-1].split(',')])
      elif type == 'Bool':
        value = value=="True"
      elif type == 'Trigger':
        value = ""
      else:
        if type not in ('Enum', 'String'):
          mevis.MLAB.log("Maybe type %s should be supported?!" % (type))
      return value
    # --------------------------------------------------------------------------------------------}}}-
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __init__ ----------------------------------------------------------------------------{{{-
  
  def __init__ (self, name, ctx, xmlNode=None):
    self.__name = name
    self.__ctx = ctx
    self.__fieldValueListDict = { 'Parameterization': FieldValueTestCase.FieldValueList('Parameterization'),
                                  'ExpectedResults': FieldValueTestCase.FieldValueList('ExpectedResults'),
                                  'ResultsToSave': FieldValueTestCase.FieldList('ResultsToSave'),
                                  'SavedResults':{} }
 
    # If an XML node is given load it.
    if xmlNode:
      self.__load(xmlNode)
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getName -----------------------------------------------------------------------------{{{-
  
  def getName (self):
    return self.__name
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def setName -----------------------------------------------------------------------------{{{-
  
  def setName (self, name):
    self.__name = name
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def save --------------------------------------------------------------------------------{{{-
  
  def save (self, xmlNode=None):
    # Create an empty XML node if none was specified. Otherwise clean the
    # existing node and put the current settings in.
    if not xmlNode:
      xmlNode = etree.Element('FieldValueTestCase', name=self.__name)
      settingsNode = etree.SubElement(xmlNode, 'Settings')
      resultsNode = etree.SubElement(xmlNode, 'Results')
    else:
      settingsNode = xmlNode.find('Settings')
      resultsNode = xmlNode.find('Results')
      settingsNode.clear()
      resultsNode.clear()
 
    # Save the settings.
    settingsNode.append(self.__fieldValueListDict['Parameterization'].save())
    settingsNode.append(self.__fieldValueListDict['ExpectedResults'].save())
    settingsNode.append(self.__fieldValueListDict['ResultsToSave'].save())
    for result in self.__fieldValueListDict['SavedResults']:
      resultsNode.append(self.__fieldValueListDict['SavedResults'][result].save())
 
    return xmlNode
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getParameterization -----------------------------------------------------------------{{{-
  
  def getParameterization (self):
    return self.__fieldValueListDict['Parameterization']
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def applyParameterization ---------------------------------------------------------------{{{-
  
  def applyParameterization (self, changeSet, verbose=False):
    for item in self.__fieldValueListDict['Parameterization']:
      fieldName = "%s.%s" % (item[0], item[1])
      if item[2] in ("Trigger"):
        self.__ctx.field(fieldName).touch()
      else:
        changeSet.setFieldValue(fieldName, item[3], verbose=verbose)
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getExpectedResults ------------------------------------------------------------------{{{-
  
  def getExpectedResults (self):
  
    return self.__fieldValueListDict['ExpectedResults']
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def verifyExpectedResults ---------------------------------------------------------------{{{-
  
  def verifyExpectedResults (self, failedFieldList=[], findAll=False, verbose=False):
    retValue = True
    for item in self.__fieldValueListDict['ExpectedResults']:
      fieldName = "%s.%s" % (item[0], item[1])
      field = self.__ctx.field(fieldName)
      if not field:
        if verbose:
          mevis.MLAB.logError("Unknown field: %s." % (fieldName))
      else:
        match = False
        if field.type in ("Float", "Double"):
          # TODO Use configurable epsilon.
          match = abs(field.value-item[3]) < 0.0001
        else:
          match = field.value == item[3]
        if not match:
          failedFieldList.append(fieldName)
          if verbose:
            mevis.MLAB.logError("Field %s: Value %s does not match expected value %s!" % (fieldName, field.value, item[3]))
          if not findAll:
            return False
          retValue = False
    return retValue
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getResultsToSave --------------------------------------------------------------------{{{-
  
  def getResultsToSave (self):
    return self.__fieldValueListDict['ResultsToSave']
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def saveResults -------------------------------------------------------------------------{{{-
  
  def saveResults (self, name, overwrite=False):
    retVal = True
    if not overwrite and name in self.__fieldValueListDict['SavedResults']:
      mevis.MLAB.logError("Result with name %s available already." % (name))
      retVal = False
    else:
      resList = self.__fieldValueListDict['SavedResults'][name] = FieldValueTestCase.FieldValueList(name)
      for item in self.__fieldValueListDict['ResultsToSave']:
        fldName = "%s.%s" % (item[0], item[1])
        if item[2] == "Trigger":
          self.__ctx.field(fldName).touch()
          fldValue = ""
        else:
          fldValue = self.__ctx.field(fldName).value
        resList.append(tuple((item[0], item[1], item[2], fldValue)))
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getSavedResultList ------------------------------------------------------------------{{{-
  
  def getSavedResultList (self):
    return sorted(self.__fieldValueListDict['SavedResults'].keys())
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def addSavedResultList ------------------------------------------------------------------{{{-
  
  def addSavedResultList (self, name, resultList):
    retVal = True
    if name in self.__fieldValueListDict['SavedResults']:
      mevis.MLAB.logError("Result with name %s available already." % (name))
      retVal = False
    else:
      resList = FieldValueTestCase.FieldValueList(name)
      resToSaveList = []
      for item in self.__fieldValueListDict['ResultsToSave']:
        resToSaveList.append("%s.%s" % (item[0], item[1]))
      for item in resultList:
        field = "%s.%s" % (item[0], item[1])
        if not field in resToSaveList:
          mevis.MLAB.logError("Field %s not in list of results to save. Ignoring it." % (field))
        else:
          resList.add(item)
      self.__fieldValueListDict['SavedResults'][name] = resList
    return retVal
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def getSavedResult ----------------------------------------------------------------------{{{-
  
  def getSavedResult (self, name):
    if name not in self.__fieldValueListDict['SavedResults']:
      mevis.MLAB.logError('No result with name %s available.' % (name))
      return None
    return self.__fieldValueListDict['SavedResults'][name]
  # --------------------------------------------------------------------------------------------}}}-
 
  # -- def __load ------------------------------------------------------------------------------{{{-
  
  def __load (self, xmlNode):
    node = xmlNode.find('Settings')
    for fieldValueListNode in node.findall('FieldValueList'):
      self.__fieldValueListDict[fieldValueListNode.get('name')].load(fieldValueListNode)
    for fieldListNode in node.findall('FieldList'):
      self.__fieldValueListDict[fieldListNode.get('name')].load(fieldListNode)
    for resultNode in xmlNode.findall('Results/FieldValueList'):
      name = resultNode.get('name')
      self.__fieldValueListDict['SavedResults'].setdefault(name, FieldValueTestCase.FieldValueList(name))
      self.__fieldValueListDict['SavedResults'][name].load(resultNode)
  # --------------------------------------------------------------------------------------------}}}-
# ----------------------------------------------------------------------------------------------}}}-
 
#//# MeVis signature v1
#//# key: MFowDQYJKoZIhvcNAQEBBQADSQAwRgJBANEfsmYse2e1dRhkQ9AQbreCq9uxwzWLoGom13MNYmyfwoJqQOEXljLFAgw2eEjaT12G4CdqKWhRxh9ANP6n7GMCARE=:VI/mB8bT4u+mRtf/ru8yUQi8BzpaS3UeL2x62YxsUYnVqCWuLrVNLiukIIjnJMKQXlc8ezmgOIcVAV7pgvgKpQ==
#//# owner: MeVis
#//# date: 2010-11-26T09:00:38
#//# hash: rMwMlcYQJQHOxPbybrFYtdjiuX+LFIHs/PgH3XbmXzWLw97M+Pv+FGNwyD0VMD9vLOsMHIIyRwUumHpGFR6koQ==
#//# MeVis end