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)
        self.__changeSet.enableAutoRevert(False)
 
        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