Exemplo n.º 1
0
def printResult(result):
    '''
    Prints the given test result.
    '''
    log.debug("Print test result: %s" % result)
    summary = result.get(name=SUMMARY_CHANNEL)[0].getSummary()
    log.info("Print summary of test execution results: %s" % summary)
    report = "Ran %d of %d test cases in %s" % (summary[COUNTER_TESTS_RUN],
                                                summary[COUNTER_N_TESTS],
                                                summary[COUNTER_RUN_TIME])
    print '\n', report
    printSeparator(len(report))
    if summary[STATUS_PASSED]:
        print "Tests passed:\t\t%d" % summary[STATUS_PASSED]
    if summary[STATUS_FAILED]:
        print "Tests failed:\t\t%d" % summary[STATUS_FAILED]
    if summary[STATUS_NOT_COMPLETED]:
        print "Tests not completed:\t%d" % summary[STATUS_NOT_COMPLETED]
    if summary[COUNTER_CORE_DUMPS]:
        print "Core dumps:\t\t%d" % summary[COUNTER_CORE_DUMPS]
    if summary[STATUS_ERROR]:
        print "Tests error:\t\t%d" % summary[STATUS_ERROR]
    filechls = [chl for chl in result.get(cls=channels.TestResultFileChannel)
                    if chl.isActive()]
    if filechls:
        print "Result file:" if len(filechls) == 1 else "Result files:"
        for channel in filechls:
            print "\t%s" % channel.filePath()
    printSeparator()

    status = (1 if (summary[STATUS_FAILED] + summary[STATUS_ERROR] +
                    summary[STATUS_NOT_COMPLETED]) else 0)
    exitWithStatus("FAILURE" if status else "SUCCESS", status)
Exemplo n.º 2
0
def base_random_search(
        mask_list, n_samples,
        N):  # mask_list defines a subspace for searching. N is the dimension.
    printSeparator()
    printSeparator()
    print("Running random search as the base algorithm.")
    x, y = samplings.batch_sampling(mask_list, n_samples,
                                    N)  # Just call the batch sampling method
    return np.min(y)  # return the y vector
Exemplo n.º 3
0
def runTestCases(tests, locations, devices):
    '''
    A function responsible for running the given test cases.
    '''
    log.debug("Run test cases from '%s' locations using '%s' devices: %s"
               % (", ".join(locations), ", ".join([str(d) for d in devices]),
                  ", ".join(tests)))
    loader = TestLoader()
    amountToRun = 0
    for path in locations:
        location.add(path)
    if not isinstance(tests, (list, tuple)):
        tests = [tests]
    suites, errors = loader.loadFromNames(*tests)

    ncases = 0
    for test in suites:
        ncases += test.count()
    print (" LOADED %d TEST CASES " % ncases).center(80, '-') + '\n'

    if len(errors) > 0:
        print "There were errors during loading test cases:"
        for error in errors:
            print "%s\n%s" % (error.name, error.traceback)
            printSeparator()
        print

    if not ncases:
        #Nothing to do
        exitWithStatus(status=0)

    log.info("Start running tests: %s" % suites)
    channels.add("SummaryChannel", SUMMARY_CHANNEL)
    result = testresult.TestResult()
    runner = TestRunner(devices, suites, result)

    for device in devices:
        device.connect()
    try:
        runner.start()
        runner.join()
    except KeyboardInterrupt:
        runner.stop()
    finally:
        for device in devices:
            if device.isConnected():
                device.disconnect()
    return result
Exemplo n.º 4
0
def printAccessibleDetails(accessible, attribute):
    '''
    Prints details about the given accessible.
    '''
    log.debug("Print details about accessible: %s" % accessible)
    printSeparator()
    for attr in _ATTRS_BASIC:
        name, func = attr[:2]
        func(accessible, name, *attr[2:])
    print
    for attr in _ATTRS_EXTRA:
        name, func = attr[:2]
        if name != attribute and attribute != "all":
            continue
        if not func(accessible, name, *attr[2:]) and name == attribute:
            print "Element has no %s" % name
Exemplo n.º 5
0
def printAccessibleDetails(accessible, attribute):
    '''
    Prints details about the given accessible.
    '''
    log.debug("Print details about accessible: %s" % accessible)
    printSeparator()
    for attr in _ATTRS_BASIC:
        name, func = attr[:2]
        func(accessible, name, *attr[2:])
    print
    for attr in _ATTRS_EXTRA:
        name, func = attr[:2]
        if name != attribute and attribute != "all":
            continue
        if not func(accessible, name, *attr[2:]) and name == attribute:
            print "Element has no %s" % name
Exemplo n.º 6
0
def printAccessibleTree(accessible):
    '''
    Prints the given accessible tree recursively.
    '''
    log.debug("Print accessible tree: %s" % accessible)
    lens = [len(attr[2 if len(attr) > 2 else 0]) for attr in _ATTRS_BASIC]
    _countColumnLens(accessible, lens)
    # Print column header
    row = []
    for i, attr in enumerate(_ATTRS_BASIC):
        name = attr[2 if len(attr) > 2 else 0]
        row.append(name.upper().center(lens[i]))
    length = (sum(lens) + len(lens) - 1)
    printSeparator(length)
    print _COLUMN_SEPARATOR.join(row)
    printSeparator(length)
    # Print accessible tree
    log.info("Print accessible tree using column lengths: %s"
              % ", ".join([str(i) for i in lens]))
    _printAccessibleAligned(accessible, lens)
Exemplo n.º 7
0
def printAccessibleTree(accessible):
    '''
    Prints the given accessible tree recursively.
    '''
    log.debug("Print accessible tree: %s" % accessible)
    lens = [len(attr[2 if len(attr) > 2 else 0]) for attr in _ATTRS_BASIC]
    _countColumnLens(accessible, lens)
    # Print column header
    row = []
    for i, attr in enumerate(_ATTRS_BASIC):
        name = attr[2 if len(attr) > 2 else 0]
        row.append(name.upper().center(lens[i]))
    length = (sum(lens) + len(lens) - 1)
    printSeparator(length)
    print _COLUMN_SEPARATOR.join(row)
    printSeparator(length)
    # Print accessible tree
    log.info("Print accessible tree using column lengths: %s" %
             ", ".join([str(i) for i in lens]))
    _printAccessibleAligned(accessible, lens)
Exemplo n.º 8
0
LassoSolver = linear_model.Lasso(fit_intercept=True, alpha=opt.alpha)     # Lasso solver

def getBasisValue(input,basis,featureIDList): # Return the value of a basis
    ans=0
    for (weight,pos) in basis:                  # for every term in the basis
        term=weight
        for entry in featureIDList[pos]:        # for every variable in the term
            term=term*input[entry]
        ans+=term
    return ans

selected_degree=opt.degree

for currentStage in range(opt.nStage):                      # Multi-stage Lasso
    printSeparator()
    print("Stage",currentStage)
    print("Sampling..")
    x,y=batch_sampling(maskList, opt.nSample, opt.N)        # Get a few samples at this stage
    bestAnswer=min(np.min(y), bestAnswer)                   # Update the best answer

    for i in range(0,len(y)):
        for basis in learnedFeature:
            y[i]-=getBasisValue(x[i],basis,featureIDList)     # Remove the linear component previously learned

    def get_features(x,degree):
        print("Extending feature vectors with degree "+str(degree)+" ..")
        featureExtender = PolynomialFeatures(degree, interaction_only=True)   # This function generates low degree monomials. It's a little bit slow though. You may write your own function using recursion.
        tmp=[]
        for current_x in x:
            tmp.append(featureExtender.fit_transform(np.array(current_x).reshape(1, -1))[0].tolist())   # Extend feature vectors with monomials
Exemplo n.º 9
0
def performRequest(device, options):
    '''
    Performs a request on the given device using the specified options.

    :param device: A device to perform the request on
    :type device: tadek.connection.device.Device
    :param options: Options representing the request
    :type params: dictionary
    '''
    log.debug("Perform a request on '%s' device using options: %s"
               % (device, options))
    path = accessible.Path(*options.pop("path").split('/')[1:])
    device.connect()
    try:
        if "action" in options:
            status = device.doAccessible(path, options["action"])
        elif "set-text" in options:
            text = options["set-text"]
            status = device.setAccessible(path, text=text)
        elif "set-text-file" in options:
            fn = options["set-text-file"]
            if not os.path.isfile(fn):
                exitWithError("There is no such file: %s" % fn)
            fd = None
            try:
                fd = open(fn)
                text = fd.read()
            finally:
                if fd:
                    fd.close()
            status = device.setAccessible(path, text=text)
        elif "set-value" in options:
            value = float(options["set-value"])
            status = device.setAccessible(path, value=value)
        elif "mouse-click" in options:
            x, y = options["mouse-click"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "CLICK")
        elif "mouse-double-click" in options:
            x, y = options["mouse-double-click"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y),
                                       button, "DOUBLE_CLICK")
        elif "mouse-press" in options:
            x, y = options["mouse-press"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "PRESS")
        elif "mouse-release" in options:
            x, y = options["mouse-release"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "RELEASE")
        elif "mouse-absolute-motion" in options:
            x, y = options["mouse-absolute-motion"]
            status = device.mouseEvent(path, int(x), int(y),
                                       '', "ABSOLUTE_MOTION")
        elif "mouse-relative-motion" in options:
            x, y = options["mouse-relative-motion"]
            status = device.mouseEvent(path, int(x), int(y),
                                       '', "RELATIVE_MOTION")
        elif "key" in options:
            key = options["key"].upper()
            if key in constants.KEY_SYMS:
                key = constants.KEY_SYMS[key]
            elif len(key) == 1:
                key = ord(key)
            elif key.startswith("0X"):
                key = int(key, 16)
            else:
                key = int(key)
            if "modifiers" in options:
                modifiers = [constants.KEY_CODES[mod]
                                    for mod in options["modifiers"]]
            else:
                modifiers = []
            status = device.keyboardEvent(path, key, modifiers)
        elif "dump" in options or "dump-all" in options:
            all = False
            if "dump" in options:
                depth = int(options["dump"])
            else:
                depth = -1
            if "output" in options:
                fn = options["output"]
                all = True
            obj = device.getAccessible(path, depth, all=all)
            if obj is None:
                exitWithStatus("There is no such path: %s" % path, 1)
            if all:
                printSeparator()
                utils.saveXml(obj.marshal(), fn)
                exitWithStatus("Dump saved to file: %s" % fn)
            else:
                printAccessibleTree(obj)
                exitWithStatus()
        else:
            for name in (["all"] + [attr[0] for attr in _ATTRS_EXTRA]):
                if name in options:
                    break
            else:
                exitWithError("Invalid request options: %s" % options)
            obj = device.getAccessible(path, 0, **{name: True})
            if obj is None:
                exitWithStatus("There is no such path: %s" % path, 1)
            printAccessibleDetails(obj, name)
            exitWithStatus()
    finally:
        if device.isConnected():
            device.disconnect()
    printSeparator()
    if status:
        exitWithStatus("SUCCESS")
    else:
        exitWithStatus("FAILURE", 1)
Exemplo n.º 10
0
def base_hyperband(mask_list, budget, N):  #use hyperband to search the space
    printSeparator()
    printSeparator()
    print("Running hyperband as the base algorithm.")
    max_iter = 100  # Total iterations
    eta = 3.0  # hyperparameter eta

    def logeta(x, eta):
        return np.log(x) / np.log(eta)

    s_max = int(np.floor(logeta(max_iter, eta)))  # range for hyperparameter s
    B = budget // (s_max + 1)  # budget for each s
    print("B=", B)
    print("Smax=", s_max)
    s_min = 0  # minimum s=0, this case is just random search
    best_ans = 100000  # best answer

    print('WARNING! Please implement the intermediate sampling algorithm.')
    print(
        'The current intermediate sampling algorithm is trivial. It cannot be applied to your application.'
    )

    for s in range(s_min, s_max + 1):  # For every s, do the following
        printSeparator()
        print("s=", s)
        n = int(np.floor(
            B / max_iter / (s + 1) *
            np.power(eta, s)))  # number of initial random configurations
        print("n=", n)
        x = []
        for i in range(n):
            x.append(samplings.mask_random_sample(
                mask_list, N))  # Get some random initial configurations
        remaining = n  # The number of remaining configurations
        endEpoch = int(max_iter * np.power(
            eta, -s))  # The first time we start to remove a few configurations

        lastEpoch = 0  # The last time we remove a few configurations
        for i in range(s + 1):  # for s steps
            print("Remaining..", remaining)
            print("r=", endEpoch)

            ###########################
            # Please implement the intermediate sampling algorithm for y, based on x
            # The current implementation is a trivial one. CANNOT BE APPLIED TO YOUR APPLICATION!
            y = samplings.batch_intermediate_sampling(x[:remaining], lastEpoch,
                                                      endEpoch)
            ###########################

            best_ans = min(np.min(y), best_ans)  # Update best answer
            sorted_ind = np.argsort(y)  # Sort y
            remaining = int(np.ceil(remaining /
                                    eta))  # remove a few configurations.
            lastEpoch = endEpoch  # Update the last epoch
            endEpoch = np.ceil(endEpoch * eta)  # Update the end epoch
            if endEpoch > max_iter:
                endEpoch = max_iter
            tmpx = x[:]
            for j in range(0, remaining):  # Only keep the best configurations
                tmpx[j] = x[sorted_ind[j]]
            x = tmpx[:]

    return best_ans
Exemplo n.º 11
0
def performRequest(device, options):
    '''
    Performs a request on the given device using the specified options.

    :param device: A device to perform the request on
    :type device: tadek.connection.device.Device
    :param options: Options representing the request
    :type params: dictionary
    '''
    log.debug("Perform a request on '%s' device using options: %s" %
              (device, options))
    path = accessible.Path(*options.pop("path").split('/')[1:])
    device.connect()
    try:
        if "action" in options:
            status = device.doAccessible(path, options["action"])
        elif "set-text" in options:
            text = options["set-text"]
            status = device.setAccessible(path, text=text)
        elif "set-text-file" in options:
            fn = options["set-text-file"]
            if not os.path.isfile(fn):
                exitWithError("There is no such file: %s" % fn)
            fd = None
            try:
                fd = open(fn)
                text = fd.read()
            finally:
                if fd:
                    fd.close()
            status = device.setAccessible(path, text=text)
        elif "set-value" in options:
            value = float(options["set-value"])
            status = device.setAccessible(path, value=value)
        elif "mouse-click" in options:
            x, y = options["mouse-click"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "CLICK")
        elif "mouse-double-click" in options:
            x, y = options["mouse-double-click"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button,
                                       "DOUBLE_CLICK")
        elif "mouse-press" in options:
            x, y = options["mouse-press"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "PRESS")
        elif "mouse-release" in options:
            x, y = options["mouse-release"]
            button = options["button"]
            status = device.mouseEvent(path, int(x), int(y), button, "RELEASE")
        elif "mouse-absolute-motion" in options:
            x, y = options["mouse-absolute-motion"]
            status = device.mouseEvent(path, int(x), int(y), '',
                                       "ABSOLUTE_MOTION")
        elif "mouse-relative-motion" in options:
            x, y = options["mouse-relative-motion"]
            status = device.mouseEvent(path, int(x), int(y), '',
                                       "RELATIVE_MOTION")
        elif "key" in options:
            key = options["key"].upper()
            if key in constants.KEY_SYMS:
                key = constants.KEY_SYMS[key]
            elif len(key) == 1:
                key = ord(key)
            elif key.startswith("0X"):
                key = int(key, 16)
            else:
                key = int(key)
            if "modifiers" in options:
                modifiers = [
                    constants.KEY_CODES[mod] for mod in options["modifiers"]
                ]
            else:
                modifiers = []
            status = device.keyboardEvent(path, key, modifiers)
        elif "dump" in options or "dump-all" in options:
            all = False
            if "dump" in options:
                depth = int(options["dump"])
            else:
                depth = -1
            if "output" in options:
                fn = options["output"]
                all = True
            obj = device.getAccessible(path, depth, all=all)
            if obj is None:
                exitWithStatus("There is no such path: %s" % path, 1)
            if all:
                printSeparator()
                utils.saveXml(obj.marshal(), fn)
                exitWithStatus("Dump saved to file: %s" % fn)
            else:
                printAccessibleTree(obj)
                exitWithStatus()
        else:
            for name in (["all"] + [attr[0] for attr in _ATTRS_EXTRA]):
                if name in options:
                    break
            else:
                exitWithError("Invalid request options: %s" % options)
            obj = device.getAccessible(path, 0, **{name: True})
            if obj is None:
                exitWithStatus("There is no such path: %s" % path, 1)
            printAccessibleDetails(obj, name)
            exitWithStatus()
    finally:
        if device.isConnected():
            device.disconnect()
    printSeparator()
    if status:
        exitWithStatus("SUCCESS")
    else:
        exitWithStatus("FAILURE", 1)