utils.py 31.1 KB
Newer Older
1 2
#############################################################################
##
3
## Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
## Contact: http://www.qt-project.org/legal
##
## This file is part of Qt Creator.
##
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and Digia.  For licensing terms and
## conditions see http://qt.digia.com/licensing.  For further information
## use the contact form at http://qt.digia.com/contact-us.
##
## GNU Lesser General Public License Usage
## Alternatively, this file may be used under the terms of the GNU Lesser
## General Public License version 2.1 as published by the Free Software
## Foundation and appearing in the file LICENSE.LGPL included in the
## packaging of this file.  Please review the following information to
## ensure the GNU Lesser General Public License version 2.1 requirements
## will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
##
## In addition, as a special exception, Digia gives you certain additional
## rights.  These rights are described in the Digia Qt LGPL Exception
## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
##
#############################################################################

30
import tempfile
31

32 33
def neededFilePresent(path):
    found = os.path.exists(path)
34 35 36
    if os.getenv("SYSTEST_DEBUG") == "1":
        checkAccess(path)
    elif not found:
37 38 39
        test.fatal("Missing file or directory: " + path)
    return found

40
def tempDir():
41 42 43 44
    Result = os.path.abspath(os.getcwd()+"/../../testing")
    if not os.path.exists(Result):
        os.mkdir(Result)
    return tempfile.mkdtemp(prefix="qtcreator_", dir=Result)
45 46 47 48 49

def deleteDirIfExists(path):
    shutil.rmtree(path, True)

def verifyChecked(objectName):
50
    object = waitForObject(objectName)
51 52 53
    test.compare(object.checked, True)
    return object

54
def ensureChecked(objectName, shouldBeChecked = True, timeout=20000):
55
    if shouldBeChecked:
56
        targetState = Qt.Checked
57 58
        state = "checked"
    else:
59
        targetState = Qt.Unchecked
60
        state = "unchecked"
61 62 63 64 65 66 67 68 69 70 71 72 73
    widget = waitForObject(objectName, timeout)
    try:
        # needed for transition Qt::PartiallyChecked -> Qt::Checked -> Qt::Unchecked
        clicked = 0
        while not waitFor('widget.checkState() == targetState', 1000) and clicked < 2:
            clickButton(widget)
            clicked += 1
        test.verify(waitFor("widget.checkState() == targetState", 1000))
    except:
        # widgets not derived from QCheckbox don't have checkState()
        if not waitFor('widget.checked == shouldBeChecked', 1000):
            clickButton(widget)
        test.verify(waitFor("widget.checked == shouldBeChecked", 1000))
74 75
    test.log("New state for QCheckBox: %s" % state,
             str(objectName))
76
    return widget
77

78 79 80 81 82 83
# verify that an object is in an expected enable state. Returns the object.
# param objectSpec  specifies the object to check. It can either be a string determining an object
#                   or the object itself. If it is an object, it must exist already.
# param expectedState is the expected enable state of the object
def verifyEnabled(objectSpec, expectedState = True):
    if isinstance(objectSpec, (str, unicode)):
84
        waitFor("object.exists('" + str(objectSpec).replace("'", "\\'") + "')", 20000)
85 86 87 88 89 90 91 92
        foundObject = findObject(objectSpec)
    else:
        foundObject = objectSpec
    if objectSpec == None:
        test.warning("No valid object in function verifyEnabled.")
    else:
        test.compare(foundObject.enabled, expectedState)
    return foundObject
93

94 95 96 97
# select an item from a combo box
# param objectSpec  specifies the combo box. It can either be a string determining an object
#                   or the object itself. If it is an object, it must exist already.
# param itemName is the item to be selected in the combo box
98
# returns True if selection was changed or False if the wanted value was already selected
99 100
def selectFromCombo(objectSpec, itemName):
    object = verifyEnabled(objectSpec)
101 102 103
    if itemName == str(object.currentText):
        return False
    else:
104
        mouseClick(object, 5, 5, 0, Qt.LeftButton)
105
        snooze(1)
106
        mouseClick(waitForObjectItem(object, itemName.replace(".", "\\.")), 5, 5, 0, Qt.LeftButton)
107 108
        test.verify(waitFor("str(object.currentText)==itemName", 5000),
                    "Switched combo item to '%s'" % itemName)
109
        return True
110

111 112 113
def selectFromLocator(filter, itemName = None):
    if itemName == None:
        itemName = filter
114
    itemName = itemName.replace(".", "\\.").replace("_", "\\_")
115
    locator = waitForObject(":*Qt Creator_Utils::FilterLineEdit")
116 117 118 119 120 121 122 123
    mouseClick(locator, 5, 5, 0, Qt.LeftButton)
    replaceEditorContent(locator, filter)
    # clicking the wanted item
    # if you replace this by pressing ENTER, be sure that something is selected
    # otherwise you will run into unwanted behavior
    wantedItem = waitForObjectItem("{type='QTreeView' unnamed='1' visible='1'}", itemName)
    doubleClick(wantedItem, 5, 5, 0, Qt.LeftButton)

124
def wordUnderCursor(window):
125
    return textUnderCursor(window, QTextCursor.StartOfWord, QTextCursor.EndOfWord)
126 127

def lineUnderCursor(window):
128 129 130
    return textUnderCursor(window, QTextCursor.StartOfLine, QTextCursor.EndOfLine)

def textUnderCursor(window, fromPos, toPos):
131 132
    cursor = window.textCursor()
    oldposition = cursor.position()
133 134
    cursor.movePosition(fromPos)
    cursor.movePosition(toPos, QTextCursor.KeepAnchor)
135 136 137 138 139 140 141 142
    returnValue = cursor.selectedText()
    cursor.setPosition(oldposition)
    return returnValue

def which(program):
    def is_exe(fpath):
        return os.path.exists(fpath) and os.access(fpath, os.X_OK)

143 144 145
    def callableFile(path):
        if is_exe(path):
            return path
146
        if platform.system() in ('Windows', 'Microsoft'):
147 148 149 150
            for suffix in suffixes.split(os.pathsep):
                if is_exe(path + suffix):
                    return path + suffix
        return None
151

152 153 154 155 156 157 158 159 160
    if platform.system() in ('Windows', 'Microsoft'):
        suffixes = os.getenv("PATHEXT")
        if not suffixes:
            test.fatal("Can't read environment variable PATHEXT. Please check your installation.")
            suffixes = ""

    fpath, fname = os.path.split(program)
    if fpath:
        return callableFile(program)
161
    else:
162 163 164 165
        if platform.system() in ('Windows', 'Microsoft'):
            cf = callableFile(os.getcwd() + os.sep + program)
            if cf:
                return cf
166 167
        for path in os.environ["PATH"].split(os.pathsep):
            exe_file = os.path.join(path, program)
168 169 170 171
            cf = callableFile(exe_file)
            if cf:
                return cf
        return None
172

173 174 175 176 177 178 179
# this function removes the user files of given pro file(s)
# can be called with a single string object or a list of strings holding path(s) to
# the pro file(s) returns False if it could not remove all user files or has been
# called with an unsupported object
def cleanUpUserFiles(pathsToProFiles=None):
    if pathsToProFiles==None:
        return False
180
    if isinstance(pathsToProFiles, (str, unicode)):
181
        filelist = glob.glob(pathsToProFiles+".user*")
182
    elif isinstance(pathsToProFiles, (list, tuple)):
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
        filelist = []
        for p in pathsToProFiles:
            filelist.extend(glob.glob(p+".user*"))
    else:
        test.fatal("Got an unsupported object.")
        return False
    doneWithoutErrors = True
    for file in filelist:
        try:
            file = os.path.abspath(file)
            os.remove(file)
        except:
            doneWithoutErrors = False
    return doneWithoutErrors

198
def invokeMenuItem(menu, item, *subItems):
199 200 201 202 203
    if platform.system() == "Darwin":
        try:
            waitForObject(":Qt Creator.QtCreator.MenuBar_QMenuBar", 2000)
        except:
            nativeMouseClick(waitForObject(":Qt Creator_Core::Internal::MainWindow", 1000), 20, 20, 0, Qt.LeftButton)
204 205 206 207 208 209 210 211
    # HACK to avoid squish crash using Qt5.2 on Squish 5.0.1 - remove asap
    if platform.system() == "Darwin" and not isQt4Build:
        if menu == "Tools" and item == "Options...":
            nativeType("<Command+,>")
            return
        if menu == "File" and item == "Exit":
            nativeType("<Command+q>")
            return
Christian Stenger's avatar
Christian Stenger committed
212
    menuObject = waitForObjectItem(":Qt Creator.QtCreator.MenuBar_QMenuBar", menu)
213
    waitFor("menuObject.visible", 1000)
214
    activateItem(menuObject)
215
    itemObject = waitForObjectItem(objectMap.realName(menuObject), item)
216
    waitFor("itemObject.enabled", 2000)
217
    activateItem(itemObject)
218
    for subItem in subItems:
Christian Stenger's avatar
Christian Stenger committed
219 220
        sub = itemObject.menu()
        waitFor("sub.visible", 1000)
221 222
        itemObject = waitForObjectItem(sub, subItem)
        activateItem(itemObject)
223 224 225

def logApplicationOutput():
    # make sure application output is shown
226
    ensureChecked(":Qt Creator_AppOutput_Core::Internal::OutputPaneToggleButton")
227
    try:
228
        output = waitForObject("{type='Core::OutputWindow' visible='1' windowTitle='Application Output Window'}")
229
        test.log("Application Output:\n%s" % output.plainText)
230
        return str(output.plainText)
231 232
    except:
        test.fail("Could not find any Application Output - did the project run?")
233
        return None
234 235 236 237 238 239 240

# get the output from a given cmdline call
def getOutputFromCmdline(cmdline):
    versCall = subprocess.Popen(cmdline, stdout=subprocess.PIPE, shell=True)
    result = versCall.communicate()[0]
    versCall.stdout.close()
    return result
Christian Stenger's avatar
Christian Stenger committed
241

242
def selectFromFileDialog(fileName, waitForFile=False):
243 244 245 246 247 248 249
    if platform.system() == "Darwin":
        snooze(1)
        nativeType("<Command+Shift+g>")
        snooze(1)
        nativeType(fileName)
        snooze(1)
        nativeType("<Return>")
250
        snooze(3)
251
        nativeType("<Return>")
252
        snooze(1)
253
    else:
254
        fName = os.path.basename(os.path.abspath(fileName))
255
        pName = os.path.dirname(os.path.abspath(fileName)) + os.sep
256 257 258 259 260 261 262 263 264 265 266
        try:
            waitForObject("{name='QFileDialog' type='QFileDialog' visible='1'}", 5000)
            pathLine = waitForObject("{name='fileNameEdit' type='QLineEdit' visible='1'}")
            snooze(1)
            replaceEditorContent(pathLine, pName)
            clickButton(waitForObject("{text='Open' type='QPushButton'}"))
            waitFor("str(pathLine.text)==''")
            snooze(1)
            replaceEditorContent(pathLine, fName)
            clickButton(waitForObject("{text='Open' type='QPushButton'}"))
        except:
267 268
            nativeType("<Ctrl+a>")
            nativeType("<Delete>")
269 270 271 272
            nativeType(pName + fName)
            snooze(1)
            nativeType("<Return>")
            snooze(3)
273 274
    if waitForFile:
        fileCombo = waitForObject(":Qt Creator_FilenameQComboBox")
275 276
        if not waitFor("str(fileCombo.currentText) in fileName", 5000):
            test.fail("%s could not be opened in time." % fileName)
277

Christian Stenger's avatar
Christian Stenger committed
278 279 280
# add Qt documentations from given paths
# param which a list/tuple of the paths to the qch files to be added
def addHelpDocumentation(which):
Christian Stenger's avatar
Christian Stenger committed
281 282 283 284 285
    global sdkPath
    invokeMenuItem("Tools", "Options...")
    waitForObjectItem(":Options_QListView", "Help")
    clickItem(":Options_QListView", "Help", 14, 15, 0, Qt.LeftButton)
    waitForObject("{container=':Options.qt_tabwidget_tabbar_QTabBar' type='TabItem' text='Documentation'}")
286
    clickOnTab(":Options.qt_tabwidget_tabbar_QTabBar", "Documentation")
Christian Stenger's avatar
Christian Stenger committed
287 288
    # get rid of all docs already registered
    listWidget = waitForObject("{type='QListWidget' name='docsListWidget' visible='1'}")
289
    if listWidget.count > 0:
Christian Stenger's avatar
Christian Stenger committed
290 291
        rect = listWidget.visualItemRect(listWidget.item(0))
        mouseClick(listWidget, rect.x+5, rect.y+5, 0, Qt.LeftButton)
292
        type(listWidget, "<Ctrl+a>")
Christian Stenger's avatar
Christian Stenger committed
293
        mouseClick(waitForObject("{type='QPushButton' name='removeButton' visible='1'}"), 5, 5, 0, Qt.LeftButton)
Christian Stenger's avatar
Christian Stenger committed
294 295 296
    for qch in which:
        clickButton(waitForObject("{type='QPushButton' name='addButton' visible='1' text='Add...'}"))
        selectFromFileDialog(qch)
Christian Stenger's avatar
Christian Stenger committed
297
    clickButton(waitForObject(":Options.OK_QPushButton"))
298

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
def addCurrentCreatorDocumentation():
    currentCreatorPath = currentApplicationContext().cwd
    if platform.system() == "Darwin":
        docPath = os.path.abspath(os.path.join(currentCreatorPath, "Qt Creator.app", "Contents",
                                               "Resources", "doc", "qtcreator.qch"))
    else:
        docPath = os.path.abspath(os.path.join(currentCreatorPath, "..", "share", "doc",
                                               "qtcreator", "qtcreator.qch"))
    if not os.path.exists(docPath):
        test.fatal("Missing current Qt Creator documentation (expected in %s)" % docPath)
        return
    invokeMenuItem("Tools", "Options...")
    waitForObjectItem(":Options_QListView", "Help")
    clickItem(":Options_QListView", "Help", 14, 15, 0, Qt.LeftButton)
    waitForObject("{container=':Options.qt_tabwidget_tabbar_QTabBar' type='TabItem' text='Documentation'}")
    clickOnTab(":Options.qt_tabwidget_tabbar_QTabBar", "Documentation")
    clickButton(waitForObject("{type='QPushButton' name='addButton' visible='1' text='Add...'}"))
    selectFromFileDialog(docPath)
    try:
        waitForObject("{type='QMessageBox' unnamed='1' visible='1' "
                      "text?='Unable to register documentation.*'}", 3000)
        test.passes("Qt Creator's documentation found already registered.")
        clickButton(waitForObject("{type='QPushButton' text='OK' unnamed='1' visible='1' "
                                  "container={name='groupBox' type='QGroupBox' visible='1'}}"))
    except:
        test.fail("Added Qt Creator's documentation explicitly.")
    clickButton(waitForObject(":Options.OK_QPushButton"))

327 328 329 330 331 332
def verifyOutput(string, substring, outputFrom, outputIn):
    index = string.find(substring)
    if (index == -1):
        test.fail("Output from " + outputFrom + " could not be found in " + outputIn)
    else:
        test.passes("Output from " + outputFrom + " found at position " + str(index) + " of " + outputIn)
333

Sergio Ahumada's avatar
Sergio Ahumada committed
334
# function that verifies the existence and the read permissions
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
# of the given file path
# if the executing user hasn't the read permission it checks
# the parent folders for their execute permission
def checkAccess(pathToFile):
    if os.path.exists(pathToFile):
        test.log("Path '%s' exists" % pathToFile)
        if os.access(pathToFile, os.R_OK):
            test.log("Got read access on '%s'" % pathToFile)
        else:
            test.fail("No read permission on '%s'" % pathToFile)
    else:
        test.fatal("Path '%s' does not exist or cannot be accessed" % pathToFile)
        __checkParentAccess__(pathToFile)

# helper function for checking the execute rights of all
# parents of filePath
def __checkParentAccess__(filePath):
    for i in range(1, filePath.count(os.sep)):
        tmp = filePath.rsplit(os.sep, i)[0]
        if os.access(tmp, os.X_OK):
            test.log("Got execute permission on '%s'" % tmp)
        else:
            test.fail("No execute permission on '%s'" % tmp)
358 359

# this function checks for all configured Qt versions inside
360 361
# options dialog and returns a dict holding the kits as keys
# and a list of information of its configured Qt
362
def getConfiguredKits():
363 364 365
    def __retrieveQtVersionName__(target, version):
        treeWidget = waitForObject(":QtSupport__Internal__QtVersionManager.qtdirList_QTreeWidget")
        return treeWidget.currentItem().text(0)
366 367
    # end of internal function for iterateQtVersions
    def __setQtVersionForKit__(kit, kitName, kitsQtVersionName):
368
        treeView = waitForObject(":BuildAndRun_QTreeView")
369 370 371 372 373 374
        clickItem(treeView, kit, 5, 5, 0, Qt.LeftButton)
        qtVersionStr = str(waitForObject(":Kits_QtVersion_QComboBox").currentText)
        kitsQtVersionName[kitName] = qtVersionStr
    # end of internal function for iterate kits

    kitsWithQtVersionName = {}
375
    result = {}
376 377 378 379
    # collect kits and their Qt versions
    targetsQtVersions, qtVersionNames = iterateQtVersions(True, False, __retrieveQtVersionName__)
    # update collected Qt versions with their configured device and version
    iterateKits(True, True, __setQtVersionForKit__, kitsWithQtVersionName)
380
    # merge defined target names with their configured Qt versions and devices
381
    for kit, qtVersion in kitsWithQtVersionName.iteritems():
382 383
        if kit in ('Fremantle', 'Harmattan') and qtVersion == 'None':
            test.log("Found Kit '%s' with unassigned Qt version (disabled Madde plugin)" % kit)
384
        elif qtVersion in qtVersionNames:
385 386 387 388
            result[kit] = targetsQtVersions[qtVersionNames.index(qtVersion)].items()[0]
        else:
            test.fail("Qt version '%s' for kit '%s' can't be found in qtVersionNames."
                      % (qtVersion, kit))
389 390 391 392 393
    clickButton(waitForObject(":Options.Cancel_QPushButton"))
    # adjust device name(s) to match getStringForTarget() - some differ from time to time
    for targetName in result.keys():
        targetInfo = result[targetName]
        if targetInfo[0] == "Maemo":
394
            result.update({targetName:
Christian Stenger's avatar
Christian Stenger committed
395
                           (Targets.getStringForTarget(Targets.MAEMO5), targetInfo[1])})
396
    test.log("Configured kits: %s" % str(result))
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
    return result

def visibleCheckBoxExists(text):
    try:
        findObject("{type='QCheckBox' text='%s' visible='1'}" % text)
        return True
    except:
        return False

# this function verifies if the text matches the given
# regex inside expectedTexts
# param text must be a single str/unicode
# param expectedTexts can be str/unicode/list/tuple
def regexVerify(text, expectedTexts):
    if isinstance(expectedTexts, (str,unicode)):
        expectedTexts = [expectedTexts]
    for curr in expectedTexts:
        pattern = re.compile(curr)
        if pattern.match(text):
            return True
    return False

# function that opens Options Dialog and parses the configured Qt versions
# param keepOptionsOpen set to True if the Options dialog should stay open when
#       leaving this function
422 423
# param alreadyOnOptionsDialog set to True if you already have opened the Options Dialog
#       (if False this function will open it via the MenuBar -> Tools -> Options...)
424
# param additionalFunction pass a function or name of a defined function to execute
425 426
#       for each correctly configured item on the list of Qt versions
#       (Qt versions having no assigned toolchain, failing qmake,... will be skipped)
427 428 429 430 431 432 433 434 435 436 437 438
#       this function must take at least 2 parameters - the first is the target name
#       and the second the version of the current selected Qt version item
# param argsForAdditionalFunc you can specify as much parameters as you want to pass
#       to additionalFunction from the outside
# the function returns a list of dict holding target-version mappings if used without
# additionalFunction
# WATCH OUT! if you're using the additionalFunction parameter - this function will
# return the list mentioned above as well as the returned value(s) from
# additionalFunction. You MUST call this function like
# result, additionalResult = _iterateQtVersions(...)
# where additionalResult is the result of all executions of additionalFunction which
# means it is a list of results.
439 440
def iterateQtVersions(keepOptionsOpen=False, alreadyOnOptionsDialog=False,
                      additionalFunction=None, *argsForAdditionalFunc):
441 442
    result = []
    additionalResult = []
443 444
    if not alreadyOnOptionsDialog:
        invokeMenuItem("Tools", "Options...")
445 446
    waitForObjectItem(":Options_QListView", "Build & Run")
    clickItem(":Options_QListView", "Build & Run", 14, 15, 0, Qt.LeftButton)
447
    clickOnTab(":Options.qt_tabwidget_tabbar_QTabBar", "Qt Versions")
448 449 450
    pattern = re.compile("Qt version (?P<version>.*?) for (?P<target>.*)")
    treeWidget = waitForObject(":QtSupport__Internal__QtVersionManager.qtdirList_QTreeWidget")
    root = treeWidget.invisibleRootItem()
451
    for rootChild in dumpChildren(root):
452
        rootChildText = str(rootChild.text(0)).replace(".", "\\.").replace("_", "\\_")
453
        for subChild in dumpChildren(rootChild):
454
            subChildText = str(subChild.text(0)).replace(".", "\\.").replace("_", "\\_")
455 456 457 458
            clickItem(treeWidget, ".".join([rootChildText,subChildText]), 5, 5, 0, Qt.LeftButton)
            currentText = str(waitForObject(":QtSupport__Internal__QtVersionManager.QLabel").text)
            matches = pattern.match(currentText)
            if matches:
459 460
                target = matches.group("target").strip()
                version = matches.group("version").strip()
461
                result.append({target:version})
462 463 464 465 466 467 468 469 470 471 472
                if additionalFunction:
                    try:
                        if isinstance(additionalFunction, (str, unicode)):
                            currResult = globals()[additionalFunction](target, version, *argsForAdditionalFunc)
                        else:
                            currResult = additionalFunction(target, version, *argsForAdditionalFunc)
                    except:
                        import sys
                        t,v,tb = sys.exc_info()
                        currResult = None
                        test.fatal("Function to additionally execute on Options Dialog could not be found or "
Sergio Ahumada's avatar
Sergio Ahumada committed
473
                                   "an exception occurred while executing it.", "%s(%s)" % (str(t), str(v)))
474
                    additionalResult.append(currResult)
475
    if not keepOptionsOpen:
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
        clickButton(waitForObject(":Options.Cancel_QPushButton"))
    if additionalFunction:
        return result, additionalResult
    else:
        return result

# function that opens Options Dialog (if necessary) and parses the configured Kits
# param keepOptionsOpen set to True if the Options dialog should stay open when
#       leaving this function
# param alreadyOnOptionsDialog set to True if you already have opened the Options Dialog
#       (if False this functions will open it via the MenuBar -> Tools -> Options...)
# param additionalFunction pass a function or name of a defined function to execute
#       for each configured item on the list of Kits
#       this function must take at least 2 parameters - the first is the item (QModelIndex)
#       of the current Kit (if you need to click on it) and the second the Kit name itself
# param argsForAdditionalFunc you can specify as much parameters as you want to pass
#       to additionalFunction from the outside
# the function returns a list of Kit names if used without an additional function
# WATCH OUT! if you're using the additionalFunction parameter - this function will
# return the list mentioned above as well as the returned value(s) from
# additionalFunction. You MUST call this function like
# result, additionalResult = _iterateQtVersions(...)
# where additionalResult is the result of all executions of additionalFunction which
# means it is a list of results.
def iterateKits(keepOptionsOpen=False, alreadyOnOptionsDialog=False,
                additionalFunction=None, *argsForAdditionalFunc):
    result = []
    additionalResult = []
    if not alreadyOnOptionsDialog:
        invokeMenuItem("Tools", "Options...")
    waitForObjectItem(":Options_QListView", "Build & Run")
    clickItem(":Options_QListView", "Build & Run", 14, 15, 0, Qt.LeftButton)
508
    clickOnTab(":Options.qt_tabwidget_tabbar_QTabBar", "Kits")
509
    treeView = waitForObject(":BuildAndRun_QTreeView")
510 511 512 513 514 515 516 517
    model = treeView.model()
    test.compare(model.rowCount(), 2, "Verifying expected target section count")
    autoDetected = model.index(0, 0)
    test.compare(autoDetected.data().toString(), "Auto-detected",
                 "Verifying label for target section")
    manual = model.index(1, 0)
    test.compare(manual.data().toString(), "Manual", "Verifying label for target section")
    for section in [autoDetected, manual]:
518 519
        for currentItem in dumpItems(model, section):
            kitName = currentItem
520 521 522 523
            if (kitName.endswith(" (default)")):
                kitName = kitName.rsplit(" (default)", 1)[0]
            result.append(kitName)
            item = ".".join([str(section.data().toString()),
524
                             currentItem.replace(".", "\\.")])
525 526 527 528 529 530 531 532 533 534 535
            if additionalFunction:
                try:
                    if isinstance(additionalFunction, (str, unicode)):
                        currResult = globals()[additionalFunction](item, kitName, *argsForAdditionalFunc)
                    else:
                        currResult = additionalFunction(item, kitName, *argsForAdditionalFunc)
                except:
                    import sys
                    t,v,tb = sys.exc_info()
                    currResult = None
                    test.fatal("Function to additionally execute on Options Dialog could not be "
Sergio Ahumada's avatar
Sergio Ahumada committed
536
                               "found or an exception occurred while executing it.", "%s(%s)" %
537 538 539
                               (str(t), str(v)))
                additionalResult.append(currResult)
    if not keepOptionsOpen:
540 541 542 543 544
        clickButton(waitForObject(":Options.Cancel_QPushButton"))
    if additionalFunction:
        return result, additionalResult
    else:
        return result
545 546 547 548 549 550

# set "Always Start Full Help" in "Tools" -> "Options..." -> "Help" -> "General"
def setAlwaysStartFullHelp():
    invokeMenuItem("Tools", "Options...")
    waitForObjectItem(":Options_QListView", "Help")
    clickItem(":Options_QListView", "Help", 5, 5, 0, Qt.LeftButton)
551
    clickOnTab(":Options.qt_tabwidget_tabbar_QTabBar", "General")
552
    selectFromCombo(":Startup.contextHelpComboBox_QComboBox", "Always Show in Help Mode")
553 554 555 556 557 558 559 560 561
    clickButton(waitForObject(":Options.OK_QPushButton"))

def removePackagingDirectory(projectPath):
    qtcPackaging = os.path.join(projectPath, "qtc_packaging")
    if os.path.exists(qtcPackaging):
        test.log("Removing old packaging directory '%s'" % qtcPackaging)
        deleteDirIfExists(qtcPackaging)
    else:
        test.log("Couldn't remove packaging directory '%s' - did not exist." % qtcPackaging)
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577

# returns the indices from a QAbstractItemModel
def dumpIndices(model, parent=None, column=0):
    if parent:
        return [model.index(row, column, parent) for row in range(model.rowCount(parent))]
    else:
        return [model.index(row, column) for row in range(model.rowCount())]

DisplayRole = 0
# returns the data from a QAbstractItemModel as strings
def dumpItems(model, parent=None, role=DisplayRole, column=0):
    return [str(index.data(role)) for index in dumpIndices(model, parent, column)]

# returns the children of a QTreeWidgetItem
def dumpChildren(item):
    return [item.child(index) for index in range(item.childCount())]
578 579 580 581 582 583 584 585 586 587 588 589 590 591

def writeTestResults(folder):
    if squishinfo.version < 0x040200FF:
        print "Skipping writing test results (Squish < 4.2)"
        return
    if not os.path.exists(folder):
        print "Skipping writing test results (folder '%s' does not exist)." % folder
        return
    resultFile = open("%s.srf" % os.path.join(folder, os.path.basename(squishinfo.testCase)), "w")
    resultFile.write("suite:%s\n" % os.path.basename(os.path.dirname(squishinfo.testCase)))
    categories = ["passes", "fails", "fatals", "errors", "tests", "warnings", "xfails", "xpasses"]
    for cat in categories:
        resultFile.write("%s:%d\n" % (cat, test.resultCount(cat)))
    resultFile.close()
592 593 594 595 596 597 598 599 600

# wait and verify if object exists/not exists
def checkIfObjectExists(name, shouldExist = True, timeout = 3000, verboseOnFail = False):
    result = waitFor("object.exists(name) == shouldExist", timeout)
    if verboseOnFail and not result:
        test.log("checkIfObjectExists() failed for '%s'" % name)
    return result

# wait for progress bar(s) to appear and disappear
601
def progressBarWait(timeout=60000, warn=True):
602
    if not checkIfObjectExists(":Qt Creator_Core::Internal::ProgressBar", True, 6000):
603 604 605
        if warn:
            test.warning("progressBarWait() timed out when waiting for ProgressBar.",
                         "This may lead to unforeseen behavior. Consider increasing the timeout.")
606
    checkIfObjectExists(":Qt Creator_Core::Internal::ProgressBar", False, timeout)
607 608 609 610 611 612

def readFile(filename):
    f = open(filename, "r")
    content = f.read()
    f.close()
    return content
613 614

def simpleFileName(navigatorFileName):
615 616 617 618 619 620
    # try to find the last part of the given name, assume it's inside a (folder) structure
    search = re.search(".*[^\\\\]\.(.*)$", navigatorFileName)
    if search:
        return search.group(1).replace("\\", "")
    # it's just the filename
    return navigatorFileName.replace("\\", "")
621 622

def clickOnTab(tabBarStr, tabText, timeout=5000):
623 624 625 626 627 628 629 630
    if not waitFor("object.exists(tabBarStr)", timeout):
        raise LookupError("Could not find QTabBar: %s" % objectMap.realName(tabBarStr))
    tabBar = findObject(tabBarStr)
    if platform.system() == 'Darwin' and not tabBar.visible:
        test.log("Using workaround for Mac.")
        setWindowState(tabBar, WindowState.Normal)
    clickTab(tabBar, tabText)
    waitFor("str(tabBar.tabText(tabBar.currentIndex)) == '%s'" % tabText, timeout)
631 632 633 634 635 636 637 638 639

# constructs a string holding the properties for a QModelIndex
# param property a string holding additional properties including their values
#       ATTENTION! use single quotes for values (e.g. "text='Text'", "text='Text' occurrence='2'")
# param container the container (str) to be used for this QModelIndex
def getQModelIndexStr(property, container):
    if (container.startswith(":")):
        container = "'%s'" % container
    return ("{column='0' container=%s %s type='QModelIndex'}" % (container, property))
640 641 642 643 644 645 646 647

def verifyItemOrder(items, text):
    text = str(text)
    lastIndex = 0
    for item in items:
        index = text.find(item)
        test.verify(index > lastIndex, "'" + item + "' found at index " + str(index))
        lastIndex = index
Robert Loehning's avatar
Robert Loehning committed
648 649

def openVcsLog():
650 651 652 653 654 655 656 657 658 659 660
    try:
        foundObj = waitForObject("{type='QPlainTextEdit' unnamed='1' visible='1' "
                                 "window=':Qt Creator_Core::Internal::MainWindow'}", 2000)
        if className(foundObj) != 'QPlainTextEdit':
            raise Exception("Found derived class, but not a pure QPlainTextEdit.")
    except:
        invokeMenuItem("Window", "Output Panes", "Version Control")

def openGeneralMessages():
    if not object.exists(":Qt Creator_Core::OutputWindow"):
        invokeMenuItem("Window", "Output Panes", "General Messages")
661 662 663 664 665 666 667 668 669 670 671

# function that retrieves a specific child object by its class
# this is sometimes the best way to avoid using waitForObject() on objects that
# occur more than once - but could easily be found by using a compound object
# (e.g. search for Utils::PathChooser instead of Utils::FancyLineEdit and get the child)
def getChildByClass(parent, classToSearchFor, occurrence=1):
    children = [child for child in object.children(parent) if className(child) == classToSearchFor]
    if len(children) < occurrence:
        return None
    else:
        return children[occurrence - 1]
672 673 674

def getHelpViewer():
    try:
675
        return waitForObject(":Qt Creator_Help::Internal::HelpViewer", 3000)
676 677 678 679 680 681 682 683 684 685
    except:
        return waitForObject("{type='Help::Internal::TextBrowserHelpWidget' unnamed='1' "
                             "visible='1' window=':Qt Creator_Core::Internal::MainWindow'}", 1000)

def getHelpTitle():
    hv = getHelpViewer()
    try:
        return str(hv.title)
    except:
        return str(hv.documentTitle)
686 687 688 689

def canTestEmbeddedQtQuick():
    return (squishinfo.major * 0x10000 + squishinfo.minor * 0x100
            + squishinfo.patch) > 0x050100