Esempio n. 1
0
    def testBasicFlag(self):
        """
        tests that a flag gets output 
        """
        
        # create the parameter
        parameterName = 'test'
        parameter = ParameterModule.DataParameter(
            id=parameterName, 
            portDirection=ParameterModule.PORT_DIRECTION_INPUT)
        prefixFlag = ['-input']
        parameterAttributes = {
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:True,
                ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:True,
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE_OPTIONS:{
                    ParameterModule.COMMANDLINE_PREFIX_FLAG:prefixFlag
                    },        
                }
        ParameterModule.setAttributes(parameter, parameterAttributes)

        # create the parameter bindings
        parameterValue = ['foo']
        parameterBindings = {
            parameterName:parameterValue
        }
                
        # verify the parameter argument
        self.assertParameterArgument(parameter,
                                     parameterBindings,
                                     prefixFlag + parameterValue)
        return
Esempio n. 2
0
    def testBasic(self):
        """
        tests that the parameter's value gets output
        """

        # create the parameter
        parameterName = 'test'
        parameter = ParameterModule.DataParameter(
            id=parameterName, 
            portDirection=ParameterModule.PORT_DIRECTION_INPUT)
        parameterAttributes = {
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:True,
                ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:True,
                }
        ParameterModule.setAttributes(parameter, parameterAttributes)

        # create the parameter bindings
        parameterValue = ['foo']
        parameterBindings = {
            parameterName:parameterValue
        }
                
        # verify the parameter argument
        self.assertParameterArgument(parameter,
                                     parameterBindings,
                                     parameterValue)
        return
Esempio n. 3
0
    def testListValueWithFlag(self):
        """
        tests to ensure that a list of values is output
        along with its prefix flag (non-distributed)
        """
        # create the parameter
        parameterName = 'test'
        parameter = ParameterModule.DataParameter(
            id=parameterName, 
            portDirection=ParameterModule.PORT_DIRECTION_INPUT)
        prefixFlag = ['-input']
        parameterAttributes = {
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:True,
                ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:True,
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE_OPTIONS:{
                    ParameterModule.COMMANDLINE_PREFIX_FLAG:prefixFlag
                    },        
                }
        ParameterModule.setAttributes(parameter, parameterAttributes)

        # create the parameter bindings
        parameterValue = ['foo', 'bar']
        parameterBindings = {
            parameterName:parameterValue
        }
                
        # verify the parameter argument
        self.assertParameterArgument(parameter,
                                     parameterBindings,
                                     prefixFlag + parameterValue)
        return
Esempio n. 4
0
    def testBooleanFlagExplicitFalse(self):
        """
        tests for boolean value, explicity specified by the value
        and not by the flag, e.g.
        "-foo True" and "-foo False"
        """
        # create the parameter
        parameterName = 'test'
        parameter = ParameterModule.DataParameter(
            id=parameterName, 
            portDirection=ParameterModule.PORT_DIRECTION_INPUT)

        prefixFlag = ['-foo']
        trueValue = ['1']
        falseValue = ['0']
        parameterAttributes = {
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:True,
                ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:True,
                ParameterModule.PORT_ATTRIBUTE_ISENUM:True,
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE_OPTIONS:{
                    ParameterModule.COMMANDLINE_PREFIX_FLAG:prefixFlag,
                    ParameterModule.COMMANDLINE_ENUM_MAP:{
                        True:trueValue,
                        False:falseValue
                        }
                    },
                }
        ParameterModule.setAttributes(parameter, parameterAttributes)

        # create the parameter bindings
        parameterValue = [False]
        parameterBindings = {
            parameterName:parameterValue
        }
                
        # verify the parameter argument
        self.assertParameterArgument(parameter,
                                     parameterBindings,
                                     prefixFlag + falseValue)
        
        return
Esempio n. 5
0
    def testBooleanFlagImplicitTrue(self):
        """
        tests for boolean value, implicitly specified by the flag,
        e.g. "-foo" is True and "" is False
        """
        # create the parameter
        parameterId = uuid.uuid4().hex
        parameterName = 'test'
        parameter = ParameterModule.DataParameter(
            id=parameterId, name=parameterName, 
            portDirection=ParameterModule.PORT_DIRECTION_INPUT)

        trueValue = ['-foo']
        falseValue = []
        parameterAttributes = {
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:True,
                ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:True,
                ParameterModule.PORT_ATTRIBUTE_ISENUM:True,
                ParameterModule.PORT_ATTRIBUTE_COMMANDLINE_OPTIONS:{
                    ParameterModule.COMMANDLINE_ENUM_MAP:{
                        True:trueValue,
                        False:falseValue
                        }
                    },
                }
        ParameterModule.setAttributes(parameter, parameterAttributes)

        # create the parameter bindings
        parameterValue = [False]
        parameterBindings = {
            parameterId:parameterValue
        }
                
        # verify the parameter argument
        self.assertParameterArgument(parameter,
                                     parameterBindings,
                                     falseValue)

        return
Esempio n. 6
0
    def addPomsetParameter(self, pomset, parameterName, attributes, 
                           parameterClass=ParameterModule.DataParameter):

        # TODO:
        # should verify that the pomset
        # does not already have a parameter with the given name


        # the direction has to be specified
        # almost everything else has a default value
        direction = attributes['direction']

        isOptional = attributes.get('optional', False)
        isActive = attributes.get('active', not isOptional)
        isCommandline = attributes.get('commandline', True)
        isFile = attributes.get('file', False)
        isList = attributes.get('list', False)
        isEnum = attributes.get('enum', False)

        commandlineOptions = {}
        if isCommandline:
            prefixFlag = attributes.get('prefix flag', [])
            distributePrefixFlag = attributes.get(
                'distribute prefix flag', False)
            
            enumMap = attributes.get('enum map', {})

            commandlineOptions = {
                ParameterModule.COMMANDLINE_PREFIX_FLAG:prefixFlag,
                ParameterModule.COMMANDLINE_PREFIX_FLAG_DISTRIBUTE:distributePrefixFlag,
                ParameterModule.COMMANDLINE_ENUM_MAP:enumMap
                }
            pass

        isInputFile = (direction == ParameterModule.PORT_DIRECTION_INPUT and 
                       isFile)

        isSideEffect = (direction == ParameterModule.PORT_DIRECTION_OUTPUT and
                        isFile)
        if isSideEffect:
            # we have to do this because the output is the file
            # but the name of the file is actually the input
            direction = ParameterModule.PORT_DIRECTION_INPUT

        isKeyword = attributes.get('is keyword', False)
        keywordToPass = ''
        if isKeyword:
            keywordToPass = attributes.get('keyword to pass')

        parameterAttributes = {
            ParameterModule.PORT_ATTRIBUTE_COMMANDLINE:isCommandline,
            ParameterModule.PORT_ATTRIBUTE_ISINPUTFILE:isInputFile,
            ParameterModule.PORT_ATTRIBUTE_ISSIDEEFFECT:isSideEffect,
            ParameterModule.PORT_ATTRIBUTE_ISLIST:isList,
            ParameterModule.PORT_ATTRIBUTE_COMMANDLINE_OPTIONS:commandlineOptions,
            ParameterModule.PORT_ATTRIBUTE_KEYWORD:isKeyword,
            ParameterModule.PORT_ATTRIBUTE_KEYWORDTOPASS:keywordToPass,
            }

        parameter = parameterClass(
            id=parameterName, 
            optional=isOptional, active=isActive,
            portDirection=direction)
        parameter.name(parameterName)

        defaultValue = attributes.get('default value', None)
        if defaultValue is not None:
            parameter.defaultValue(defaultValue)

        ParameterModule.setAttributes(parameter, parameterAttributes)

        pomset.addParameter(parameter)
        pomset.parameterIsActive(parameterName, isActive)

        return parameter