diff options
Diffstat (limited to 'test')
| -rwxr-xr-x | test/test-fixed-point-parameter/Main.py | 240 |
1 files changed, 240 insertions, 0 deletions
diff --git a/test/test-fixed-point-parameter/Main.py b/test/test-fixed-point-parameter/Main.py new file mode 100755 index 0000000..09cff28 --- /dev/null +++ b/test/test-fixed-point-parameter/Main.py @@ -0,0 +1,240 @@ +#!/usr/bin/python2.7 +# +# Copyright (c) 2014, Intel Corporation +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation and/or +# other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import sys +import subprocess +from decimal import Decimal + +class FixedPointTester(): + """ Made for testing a particular Qn.m number + + As a convention, we use: + * n is the fractional part + * m is the integral part + + This class computes several specific numbers for a given Qn.m number. + + For each of those numbers, we run 4 checks: + * Bound check + * Sanity check + * Consistency check + * Bijectivity check + Which are documented below. + """ + def __init__(self, pfwClient, integral, fractional): + self._pfwClient = pfwClient + self._paramPath = '/Test/test/q%d.%d' % (integral, fractional) + + # quantum is the step we have between two numbers + # encoded in Qn.m format + self._quantum = 2 ** -fractional + + # The maximum value we can encode for a given Qn.m. + # Since we also need to encode the 0, we have one quantum missing on + # the positive maximum + self._upperAllowedBound = (2 ** integral) - self._quantum + + # The minimum value that we can encode for a given Qn.m. + # This one does not need a quantum substraction since we already did + # that on the maximum + self._lowerAllowedBound = -(2 ** integral) + + self._shouldWork = [ + Decimal(0), + Decimal(self._lowerAllowedBound), + Decimal(self._upperAllowedBound) + ] + + # bigValue is to be sure a value far out of range is refused + bigValue = (2 * self._quantum) + # little is to be sure a value just out of range is refused + littleValue = 10 ** -fractional + self._shouldBreak = [ + Decimal(self._lowerAllowedBound) - Decimal(bigValue), + Decimal(self._upperAllowedBound) + Decimal(bigValue), + Decimal(self._lowerAllowedBound) - Decimal(littleValue), + Decimal(self._upperAllowedBound) + Decimal(littleValue) + ] + + + def run(self): + """ Runs the test suite for a given Qn.m number + """ + for value in self._shouldWork: + print('Testing %s for %s' % (value, self._paramPath)) + value, success = self.checkBounds(value) + if not success: + print('Bound ERROR for %s' % self._paramPath) + continue + + value, success = self.checkSanity(value) + if not success: + print('Sanity ERROR %s' % self._paramPath) + continue + + value, success = self.checkConsistency(value) + if not success: + print('Consistency ERROR %s' % self._paramPath) + continue + + value, success = self.checkBijectivity(value) + if not success: + print('Bijectivity ERROR %s' % self._paramPath) + continue + + for value in self._shouldBreak: + print('Testing invalid value %s for %s' % (value, self._paramPath)) + value, success = self.checkBounds(value) + if success: + print("ERROR: This test should have failed but it has not") + + def checkBounds(self, valueToSet): + """ Checks if we are able to set valueToSet via the parameter-framework + + valueToSet -- the value we are trying to set + + returns: the value we are trying to set + returns: True if we are able to set, False otherwise + """ + returnCode = self._pfwClient.set(self._paramPath, str(valueToSet)) + if returnCode != 0: + return (valueToSet, False) + + return (valueToSet, True) + + + def checkSanity(self, valuePreviouslySet): + """ Checks if the value we get is still approximately the same + as we attempted to set. The value can have a slight round error which + is tolerated. + + valuePreviouslySet -- the value we had previously set + + returns: the value the parameter-framework returns us after the get + returns: True if we are able to set, False otherwise + """ + firstGet = self._pfwClient.get(self._paramPath) + + try: + returnValue = Decimal(firstGet) + except ValueError: + print("ERROR: Can't convert %s to a decimal" % firstGet) + return firstGet, False + + upperAllowedValue = Decimal(valuePreviouslySet) + (Decimal(self._quantum) / Decimal(2)) + lowerAllowedValue = Decimal(valuePreviouslySet) - (Decimal(self._quantum) / Decimal(2)) + + if not (lowerAllowedValue <= returnValue <= upperAllowedValue): + print('%s <= %s <= %s is not true' % + (lowerAllowedValue, returnValue, upperAllowedValue)) + return firstGet, False + + return firstGet, True + + def checkConsistency(self, valuePreviouslyGotten): + """ Checks if we are able to set the value that the parameter framework + just returned to us. + + valuePreviouslyGotten -- the value we are trying to set + + valueToSet -- the value we are trying to set + returns: True if we are able to set, False otherwise + """ + returnCode = pfw.set(self._paramPath, valuePreviouslyGotten) + if returnCode != 0: + return valuePreviouslyGotten, False + + return valuePreviouslyGotten, True + + def checkBijectivity(self, valuePreviouslySet): + """ Checks that the second get value is strictly equivalent to the + consistency set. This ensures that the parameter-framework behaves as + expected. + + valuePreviouslySet -- the value we had previously set + + returns: value the parameter-framework returns us after the second get + returns: True if we are able to set, False otherwise + """ + secondGet = pfw.get(self._paramPath) + if secondGet != valuePreviouslySet: + return secondGet, False + + return secondGet, True + +class PfwClient(): + + def __init__(self, configPath): + self._address = 'localhost' + self._port = '5066' + self._testPlatformPort = '5063' + self._pathToExec = 'remote-process_host' + self._configPath = configPath + + def __enter__(self): + # launch test platform in deamon mode + subprocess.call(['test-platform_host', '-d', self._configPath, self._testPlatformPort]) + subprocess.call([self._pathToExec, self._address, self._testPlatformPort, 'start']) + self._callCommand(['setTuningMode', 'on']) + return self + + def __exit__(self, type, value, traceback): + subprocess.call([self._pathToExec, self._address, self._testPlatformPort, 'exit']) + + def _callCommand(self, commandList): + shellCommand = [self._pathToExec, self._address, self._port] + shellCommand.extend(commandList) + # pipes are used to redirect the command output to a variable + subProc = subprocess.Popen(shellCommand, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + commandOutPut, _ = subProc.communicate() + returnCode = subProc.returncode + return commandOutPut, returnCode + + def set(self, parameter, value): + print('set %s <--- %s' % (parameter, value)) + (returnValue, returnCode) = self._callCommand(['setParameter', parameter, value]) + return returnCode + + def get(self, parameter): + (returnValue, _) = self._callCommand(['getParameter', parameter]) + print('get %s ---> %s' % (parameter, returnValue.strip())) + return returnValue.strip() + +if __name__ == '__main__': + # It is necessary to add a ./ in front of the path, otherwise the parameter-framework + # does not recognize the string as a path. + configPath = './ParameterFrameworkConfiguration.xml' + + with PfwClient(configPath) as pfw: + for integral in range(0, 31): + for fractional in range (0, 31 - integral): + tester = FixedPointTester(pfw, integral, fractional) + tester.run() + |