project.py 26.3 KB
Newer Older
1
import __builtin__
2 3
import re

4 5 6 7 8 9 10 11 12 13 14
processStarted = False
processExited = False

def __handleProcessStarted__(object):
    global processStarted
    processStarted = True

def __handleProcessExited__(object, exitCode):
    global processExited
    processExited = True

15
def openQmakeProject(projectPath, targets=QtQuickConstants.desktopTargetClasses(), fromWelcome=False):
16
    cleanUpUserFiles(projectPath)
17 18 19 20 21 22
    if fromWelcome:
        mouseClick(waitForObject(":OpenProject_QStyleItem"), 5, 5, 0, Qt.LeftButton)
        if not platform.system() == "Darwin":
            waitFor("waitForObject(':fileNameEdit_QLineEdit').focus == True")
    else:
        invokeMenuItem("File", "Open File or Project...")
23
    selectFromFileDialog(projectPath)
24 25
    try:
        # handle update generated files dialog
26 27 28
        waitForObject("{type='QLabel' name='qt_msgbox_label' visible='1' "
                      "text?='The following files are either outdated or have been modified*' "
                      "window={type='QMessageBox' unnamed='1' visible='1'}}", 3000)
29 30 31
        clickButton(waitForObject("{text='Yes' type='QPushButton' unnamed='1' visible='1'}"))
    except:
        pass
32
    checkedTargets = __chooseTargets__(targets)
33
    configureButton = waitForObject("{text='Configure Project' type='QPushButton' unnamed='1' visible='1'"
34
                                    "window=':Qt Creator_Core::Internal::MainWindow'}")
35
    clickButton(configureButton)
36
    return checkedTargets
37

38
def openCmakeProject(projectPath, buildDir):
39
    invokeMenuItem("File", "Open File or Project...")
40
    selectFromFileDialog(projectPath)
41 42
    replaceEditorContent("{type='Utils::BaseValidatingLineEdit' unnamed='1' visible='1'"
                         "window=':CMake Wizard_CMakeProjectManager::Internal::CMakeOpenProjectWizard'}", buildDir)
43
    clickButton(waitForObject(":CMake Wizard.Next_QPushButton"))
44
    generatorCombo = waitForObject(":Generator:_QComboBox")
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
    mkspec = __getMkspecFromQmake__("qmake")
    test.log("Using mkspec '%s'" % mkspec)

    if "win32-" in mkspec:
        generatorName = {"win32-g++" : "MinGW Generator (MinGW from SDK)",
                         "win32-msvc2008" : "NMake Generator (Microsoft Visual C++ Compiler 9.0 (x86))",
                         "win32-msvc2010" : "NMake Generator (Microsoft Visual C++ Compiler 10.0 (x86))"}
        index = -1
        if mkspec in generatorName:
            index = generatorCombo.findText(generatorName[mkspec])
        if index == -1:
            test.warning("No matching CMake generator for mkspec '%s' found." % mkspec)
        else:
            generatorCombo.setCurrentIndex(index)

60
    clickButton(waitForObject(":CMake Wizard.Run CMake_QPushButton"))
Christian Stenger's avatar
Christian Stenger committed
61 62 63 64 65 66 67 68 69 70
    try:
        clickButton(waitForObject(":CMake Wizard.Finish_QPushButton", 60000))
    except LookupError:
        cmakeOutput = waitForObject("{type='QPlainTextEdit' unnamed='1' visible='1' "
                                    "window=':CMake Wizard_CMakeProjectManager::Internal::CMakeOpenProjectWizard'}")
        test.warning("Error while executing cmake - see details for cmake output.",
                     str(cmakeOutput.plainText))
        clickButton(waitForObject(":CMake Wizard.Cancel_QPushButton"))
        return False
    return True
71

72 73 74 75
# this function returns a list of available targets - this is not 100% error proof
# because the Simulator target is added for some cases even when Simulator has not
# been set up inside Qt versions/Toolchains
# this list can be used in __chooseTargets__()
76
def __createProjectOrFileSelectType__(category, template, fromWelcome = False, isProject=True):
77 78 79 80
    if fromWelcome:
        mouseClick(waitForObject(":CreateProject_QStyleItem"), 5, 5, 0, Qt.LeftButton)
    else:
        invokeMenuItem("File", "New File or Project...")
81
    categoriesView = waitForObject("{type='QTreeView' name='templateCategoryView'}")
82 83 84 85
    if isProject:
        clickItem(categoriesView, "Projects." + category, 5, 5, 0, Qt.LeftButton)
    else:
        clickItem(categoriesView, "Files and Classes." + category, 5, 5, 0, Qt.LeftButton)
86
    templatesView = waitForObject("{name='templatesView' type='QListView'}")
87
    clickItem(templatesView, template, 5, 5, 0, Qt.LeftButton)
88
    text = waitForObject("{type='QTextBrowser' name='templateDescription' visible='1'}").plainText
89
    clickButton(waitForObject("{text='Choose...' type='QPushButton' unnamed='1' visible='1'}"))
90
    return __getSupportedPlatforms__(str(text))[0]
91

92
def __createProjectSetNameAndPath__(path, projectName = None, checks = True):
93
    directoryEdit = waitForObject("{type='Utils::BaseValidatingLineEdit' unnamed='1' visible='1'}")
94 95
    replaceEditorContent(directoryEdit, path)
    projectNameEdit = waitForObject("{name='nameLineEdit' visible='1' "
96
                                    "type='Utils::ProjectNameValidatingLineEdit'}")
97 98 99 100 101 102 103 104 105
    if projectName == None:
        projectName = projectNameEdit.text
    else:
        replaceEditorContent(projectNameEdit, projectName)
    if checks:
        stateLabel = findObject("{type='QLabel' name='stateLabel'}")
        labelCheck = stateLabel.text=="" and stateLabel.styleSheet == ""
        test.verify(labelCheck, "Project name and base directory without warning or error")
    # make sure this is not set as default location
106
    ensureChecked("{type='QCheckBox' name='projectsDirectoryCheckBox' visible='1'}", False)
107
    clickButton(waitForObject(":Next_QPushButton"))
108
    return str(projectName)
109

110 111
# Selects the Qt versions for a project
# param checks turns tests in the function on if set to True
112
# param available a list holding the available targets
113
def __selectQtVersionDesktop__(checks, available=None):
114
    checkedTargets = __chooseTargets__(QtQuickConstants.desktopTargetClasses(), available)
115
    if checks:
116 117 118 119
        cbObject = ("{type='QCheckBox' text='%s' unnamed='1' visible='1' "
                    "container={type='Utils::DetailsWidget' visible='1' unnamed='1'}}")
        verifyChecked(cbObject % "Debug")
        verifyChecked(cbObject % "Release")
120
    clickButton(waitForObject(":Next_QPushButton"))
121
    return checkedTargets
122

123
def __createProjectHandleLastPage__(expectedFiles = None):
124
    if expectedFiles != None:
125 126
        summary = str(waitForObject("{name='filesLabel' text?='<qt>Files to be added in<pre>*</pre>'"
                                    "type='QLabel' visible='1'}").text)
127 128 129 130 131 132
        lastIndex = 0
        for filename in expectedFiles:
            index = summary.find(filename)
            test.verify(index > lastIndex, "'" + filename + "' found at index " + str(index))
            lastIndex = index
    selectFromCombo(":addToVersionControlComboBox_QComboBox", "<None>")
133
    clickButton(waitForObject("{type='QPushButton' text~='(Finish|Done)' visible='1'}"))
134

135 136 137 138 139 140
def __verifyFileCreation__(path, expectedFiles):
    for filename in expectedFiles:
        if filename != path:
            filename = os.path.join(path, filename)
        test.verify(os.path.exists(filename), "Checking if '" + filename + "' was created")

141 142 143 144
# Creates a Qt GUI project
# param path specifies where to create the project
# param projectName is the name for the new project
# param checks turns tests in the function on if set to True
145
def createProject_Qt_GUI(path, projectName, checks = True):
146
    template = "Qt Gui Application"
147
    available = __createProjectOrFileSelectType__("  Applications", template)
148
    __createProjectSetNameAndPath__(path, projectName, checks)
149
    checkedTargets = __selectQtVersionDesktop__(checks, available)
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165

    if checks:
        exp_filename = "mainwindow"
        h_file = exp_filename + ".h"
        cpp_file = exp_filename + ".cpp"
        ui_file = exp_filename + ".ui"
        pro_file = projectName + ".pro"

        waitFor("object.exists(':headerFileLineEdit_Utils::FileNameValidatingLineEdit')", 20000)
        waitFor("object.exists(':sourceFileLineEdit_Utils::FileNameValidatingLineEdit')", 20000)
        waitFor("object.exists(':formFileLineEdit_Utils::FileNameValidatingLineEdit')", 20000)

        test.compare(findObject(":headerFileLineEdit_Utils::FileNameValidatingLineEdit").text, h_file)
        test.compare(findObject(":sourceFileLineEdit_Utils::FileNameValidatingLineEdit").text, cpp_file)
        test.compare(findObject(":formFileLineEdit_Utils::FileNameValidatingLineEdit").text, ui_file)

166
    clickButton(waitForObject(":Next_QPushButton"))
167

168
    expectedFiles = None
169
    if checks:
170 171
        if platform.system() in ('Windows', 'Microsoft'):
            path = os.path.abspath(path)
Robert Loehning's avatar
Robert Loehning committed
172
        path = os.path.join(path, projectName)
173
        expectedFiles = [path]
174
        expectedFiles.extend(__sortFilenamesOSDependent__(["main.cpp", cpp_file, h_file, ui_file, pro_file]))
175
    __createProjectHandleLastPage__(expectedFiles)
176

177 178
    waitForSignal("{type='CppTools::Internal::CppModelManager' unnamed='1'}", "sourceFilesRefreshed(QStringList)", 20000)
    __verifyFileCreation__(path, expectedFiles)
179
    return checkedTargets
180

181 182 183 184
# Creates a Qt Console project
# param path specifies where to create the project
# param projectName is the name for the new project
# param checks turns tests in the function on if set to True
185
def createProject_Qt_Console(path, projectName, checks = True):
186
    available = __createProjectOrFileSelectType__("  Applications", "Qt Console Application")
187
    __createProjectSetNameAndPath__(path, projectName, checks)
188
    checkedTargets = __selectQtVersionDesktop__(checks, available)
189

190 191 192 193 194 195 196
    expectedFiles = None
    if checks:
        if platform.system() in ('Windows', 'Microsoft'):
            path = os.path.abspath(path)
        path = os.path.join(path, projectName)
        cpp_file = "main.cpp"
        pro_file = projectName + ".pro"
197 198
        expectedFiles = [path]
        expectedFiles.extend(__sortFilenamesOSDependent__([cpp_file, pro_file]))
199
    __createProjectHandleLastPage__(expectedFiles)
200

201 202
    waitForSignal("{type='CppTools::Internal::CppModelManager' unnamed='1'}", "sourceFilesRefreshed(QStringList)", 10000)
    __verifyFileCreation__(path, expectedFiles)
203
    return checkedTargets
204

205
def createNewQtQuickApplication(workingDir, projectName = None, templateFile = None,
206
                                targets=QtQuickConstants.desktopTargetClasses(), qtQuickVersion=1,
207
                                fromWelcome=False):
208
    if templateFile:
209 210 211 212
        if qtQuickVersion == 2:
            test.fatal('There is no wizard "Qt Quick 2 Application (from Existing QML File)"',
                       'This is a script error. Using Qt Quick 1 instead.')
        available = __createProjectOrFileSelectType__("  Applications", "Qt Quick 1 Application (from Existing QML File)", fromWelcome)
213
    else:
214
        available = __createProjectOrFileSelectType__("  Applications", "Qt Quick %d Application (Built-in Elements)"
215
                                                % qtQuickVersion, fromWelcome)
216 217
    projectName = __createProjectSetNameAndPath__(workingDir, projectName)
    if templateFile:
218
        baseLineEd = waitForObject("{type='Utils::BaseValidatingLineEdit' unnamed='1' visible='1'}")
219
        type(baseLineEd, templateFile)
220
        nextButton = waitForObject(":Next_QPushButton")
221
        clickButton(nextButton)
222
    checkedTargets = __chooseTargets__(targets, available)
223
    snooze(1)
224
    nextButton = waitForObject(":Next_QPushButton")
225
    clickButton(nextButton)
226
    __createProjectHandleLastPage__()
227
    return checkedTargets, projectName
228 229

def createNewQtQuickUI(workingDir):
230
    __createProjectOrFileSelectType__("  Applications", "Qt Quick 1 UI")
231 232
    if workingDir == None:
        workingDir = tempDir()
233
    projectName = __createProjectSetNameAndPath__(workingDir)
234
    __createProjectHandleLastPage__()
235
    return projectName
236 237

def createNewQmlExtension(workingDir):
238
    available = __createProjectOrFileSelectType__("  Libraries", "Qt Quick 1 Extension Plugin")
239 240
    if workingDir == None:
        workingDir = tempDir()
241
    __createProjectSetNameAndPath__(workingDir)
242
    checkedTargets = __chooseTargets__(QtQuickConstants.Targets.DESKTOP_474_GCC, available)
243
    nextButton = waitForObject(":Next_QPushButton")
244 245
    clickButton(nextButton)
    nameLineEd = waitForObject("{buddy={type='QLabel' text='Object Class-name:' unnamed='1' visible='1'} "
246
                               "type='QLineEdit' unnamed='1' visible='1'}")
247 248
    replaceEditorContent(nameLineEd, "TestItem")
    uriLineEd = waitForObject("{buddy={type='QLabel' text='URI:' unnamed='1' visible='1'} "
249
                              "type='QLineEdit' unnamed='1' visible='1'}")
Robert Loehning's avatar
Robert Loehning committed
250
    replaceEditorContent(uriLineEd, "org.qt-project.test.qmlcomponents")
251
    clickButton(nextButton)
252
    __createProjectHandleLastPage__()
253
    return checkedTargets
254 255 256 257

# parameter components can only be one of the Constants defined in QtQuickConstants.Components
def __chooseComponents__(components=QtQuickConstants.Components.BUILTIN):
    rbComponentToChoose = waitForObject("{type='QRadioButton' text='%s' visible='1'}"
258
                              % QtQuickConstants.getStringForComponents(components))
259 260 261 262 263 264 265 266
    if rbComponentToChoose.checked:
        test.passes("Selected QRadioButton is '%s'" % QtQuickConstants.getStringForComponents(components))
    else:
        clickButton(rbComponentToChoose)
        test.verify(rbComponentToChoose.checked, "Selected QRadioButton is '%s'"
                % QtQuickConstants.getStringForComponents(components))

# parameter target can be an OR'd value of QtQuickConstants.Targets
267 268
# parameter availableTargets should be the result of __createProjectSelectType__()
#           or use None as a fallback
269
def __chooseTargets__(targets=QtQuickConstants.Targets.DESKTOP_474_GCC, availableTargets=None):
270 271 272 273
    if availableTargets != None:
        available = availableTargets
    else:
        # following targets depend on the build environment - added for further/later tests
274
        available = [QtQuickConstants.Targets.DESKTOP_474_GCC,
Christian Stenger's avatar
Christian Stenger committed
275
                     QtQuickConstants.Targets.MAEMO5, QtQuickConstants.Targets.EMBEDDED_LINUX,
276 277
                     QtQuickConstants.Targets.SIMULATOR, QtQuickConstants.Targets.HARMATTAN]
        if platform.system() in ('Windows', 'Microsoft'):
278
            available.remove(QtQuickConstants.Targets.EMBEDDED_LINUX)
Robert Loehning's avatar
Robert Loehning committed
279
            available.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
280
    checkedTargets = []
281 282 283 284
    for current in available:
        mustCheck = targets & current == current
        try:
            ensureChecked("{type='QCheckBox' text='%s' visible='1'}" % QtQuickConstants.getStringForTarget(current),
285
                          mustCheck, 3000)
286 287
            if (mustCheck):
                checkedTargets.append(current)
288 289
        except LookupError:
            if mustCheck:
290 291
                test.fail("Failed to check target '%s'." % QtQuickConstants.getStringForTarget(current))
            else:
292 293 294
                # Simulator has been added without knowing whether configured or not - so skip warning here?
                if current != QtQuickConstants.Targets.SIMULATOR:
                    test.warning("Target '%s' is not set up correctly." % QtQuickConstants.getStringForTarget(current))
295
    return checkedTargets
296 297 298 299 300 301 302 303 304 305 306 307 308 309

# run and close an application
# withHookInto - if set to True the function tries to attach to the sub-process instead of simply pressing Stop inside Creator
# executable - must be defined when using hook-into
# port - must be defined when using hook-into
# function - can be a string holding a function name or a reference to the function itself - this function will be called on
# the sub-process when hooking-into has been successful - if its missing simply closing the Qt Quick app will be done
# sType the SubprocessType - is nearly mandatory - except when using the function parameter
# userDefinedType - if you set sType to SubprocessType.USER_DEFINED you must(!) specify the WindowType for hooking into
# by yourself (or use the function parameter)
# ATTENTION! Make sure this function won't fail and the sub-process will end when the function returns
def runAndCloseApp(withHookInto=False, executable=None, port=None, function=None, sType=None, userDefinedType=None):
    global processStarted, processExited
    processStarted = processExited = False
310
    overrideInstallLazySignalHandler()
311 312
    installLazySignalHandler("{type='ProjectExplorer::ApplicationLaucher'}", "processStarted()", "__handleProcessStarted__")
    installLazySignalHandler("{type='ProjectExplorer::ApplicationLaucher'}", "processExited(int)", "__handleProcessExited__")
313
    runButton = waitForObject("{type='Core::Internal::FancyToolButton' text='Run' visible='1'}")
314 315 316 317 318 319 320 321 322 323 324 325 326
    clickButton(runButton)
    if sType != SubprocessType.QT_QUICK_UI:
        waitForSignal("{type='ProjectExplorer::BuildManager' unnamed='1'}", "buildQueueFinished(bool)", 300000)
        buildSucceeded = checkLastBuild()
        if not buildSucceeded:
            test.fatal("Build inside run wasn't successful - leaving test")
            invokeMenuItem("File", "Exit")
            return False
    waitFor("processStarted==True", 10000)
    if not processStarted:
        test.fatal("Couldn't start application - leaving test")
        invokeMenuItem("File", "Exit")
        return False
327
    if sType == SubprocessType.QT_QUICK_UI and os.getenv("SYSTEST_QMLVIEWER_NO_HOOK_INTO", "0") == "1":
328
        withHookInto = False
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
    if withHookInto and not validType(sType, userDefinedType):
        if function != None:
            test.warning("You did not provide a valid value for the SubprocessType value - sType, but you have "
                         "provided a function to execute on the subprocess. Please ensure that your function "
                         "closes the subprocess before exiting, or this test will not complete.")
        else:
            test.warning("You did not provide a valid value for the SubprocessType value - sType, nor a "
                         "function to execute on the subprocess. Falling back to pushing the STOP button "
                         "inside creator to terminate execution of the subprocess.")
            withHookInto = False
    if withHookInto and not executable in ("", None):
        __closeSubprocessByHookingInto__(executable, port, function, sType, userDefinedType)
    else:
        __closeSubprocessByPushingStop__(sType)
    return True

def validType(sType, userDef):
    if sType == None:
        return False
    ty = SubprocessType.getWindowType(sType)
    return ty != None and not (ty == "user-defined" and (userDef == None or userDef.strip() == ""))

def __closeSubprocessByPushingStop__(sType):
352
    ensureChecked(":Qt Creator_AppOutput_Core::Internal::OutputPaneToggleButton")
353 354 355 356
    try:
        waitForObject(":Qt Creator.Stop_QToolButton", 5000)
    except:
        pass
357 358 359 360 361 362 363
    playButton = verifyEnabled(":Qt Creator.ReRun_QToolButton", False)
    stopButton = verifyEnabled(":Qt Creator.Stop_QToolButton")
    if stopButton.enabled:
        clickButton(stopButton)
        test.verify(playButton.enabled)
        test.compare(stopButton.enabled, False)
        if sType == SubprocessType.QT_QUICK_UI and platform.system() == "Darwin":
364
            waitFor("stopButton.enabled==False")
365 366 367 368 369 370 371
            snooze(2)
            nativeType("<Escape>")
    else:
        test.fatal("Subprocess does not seem to have been started.")

def __closeSubprocessByHookingInto__(executable, port, function, sType, userDefType):
    global processExited
372
    ensureChecked(":Qt Creator_AppOutput_Core::Internal::OutputPaneToggleButton")
373
    output = waitForObject("{type='Core::OutputWindow' visible='1' windowTitle='Application Output Window'}")
374 375 376 377 378 379 380
    if port == None:
        test.warning("I need a port number or attaching might fail.")
    else:
        waitFor("'Listening on port %d for incoming connectionsdone' in str(output.plainText)" % port, 5000)
    try:
        attachToApplication(executable)
    except:
381
        test.warning("Could not attach to '%s' - using fallback of pushing STOP inside Creator." % executable)
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
        resetApplicationContextToCreator()
        __closeSubprocessByPushingStop__(sType)
        return False
    if function == None:
        if sType==SubprocessType.USER_DEFINED:
            sendEvent("QCloseEvent", "{type='%s' unnamed='1' visible='1'}" % userDefType)
        else:
            sendEvent("QCloseEvent", "{type='%s' unnamed='1' visible='1'}" % SubprocessType.getWindowType(sType))
        resetApplicationContextToCreator()
    else:
        try:
            if isinstance(function, (str, unicode)):
                globals()[function]()
            else:
                function()
        except:
            test.fatal("Function to execute on sub-process could not be found.",
                       "Using fallback of pushing STOP inside Creator.")
            resetApplicationContextToCreator()
            __closeSubprocessByPushingStop__(sType)
    waitFor("processExited==True", 10000)
    if not processExited:
        test.warning("Sub-process seems not to have closed properly.")
        try:
            resetApplicationContextToCreator()
            __closeSubprocessByPushingStop__(sType)
        except:
            pass
    return True

# this helper tries to reset the current application context back
# to creator - this strange work-around is needed _sometimes_ on MacOS
def resetApplicationContextToCreator():
    appCtxt = applicationContext("qtcreator")
    if appCtxt.name == "":
        appCtxt = applicationContext("Qt Creator")
    setApplicationContext(appCtxt)
419 420 421 422 423

# helper that examines the text (coming from the create project wizard)
# to figure out which available targets we have
# Simulator must be handled in a special way, because this depends on the
# configured Qt versions and Toolchains and cannot be looked up the same way
424 425 426 427 428 429 430 431 432
# if you set getAsStrings to True this function returns a list of strings instead
# of the constants defined in QtQuickConstants.Targets
def __getSupportedPlatforms__(text, getAsStrings=False):
    reqPattern = re.compile("requires qt (?P<version>\d+\.\d+(\.\d+)?)", re.IGNORECASE)
    res = reqPattern.search(text)
    if res:
        version = res.group("version")
    else:
        version = None
433 434 435 436 437
    if 'Supported Platforms' in text:
        supports = text[text.find('Supported Platforms'):].split(":")[1].strip().split(" ")
        result = []
        addSimulator = False
        if 'Desktop' in supports:
438
            result.append(QtQuickConstants.Targets.DESKTOP_474_GCC)
439 440
            if platform.system() in ("Linux", "Darwin"):
                result.append(QtQuickConstants.Targets.EMBEDDED_LINUX)
Robert Loehning's avatar
Robert Loehning committed
441 442
            elif platform.system() in ('Windows', 'Microsoft'):
                result.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
443 444
        if 'MeeGo/Harmattan' in supports:
            result.append(QtQuickConstants.Targets.HARMATTAN)
445 446
            addSimulator = True
        if 'Maemo/Fremantle' in supports:
447 448 449 450 451
            result.append(QtQuickConstants.Targets.MAEMO5)
            addSimulator = True
        if len(result) == 0 or addSimulator:
            result.append(QtQuickConstants.Targets.SIMULATOR)
    elif 'Platform independent' in text:
452
        result = [QtQuickConstants.Targets.DESKTOP_474_GCC, QtQuickConstants.Targets.MAEMO5,
453
                  QtQuickConstants.Targets.SIMULATOR, QtQuickConstants.Targets.HARMATTAN]
Robert Loehning's avatar
Robert Loehning committed
454 455
        if platform.system() in ('Windows', 'Microsoft'):
            result.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
456 457 458
    else:
        test.warning("Returning None (__getSupportedPlatforms__())",
                     "Parsed text: '%s'" % text)
459 460 461 462
        return None, None
    if getAsStrings:
        result = QtQuickConstants.getTargetsAsStrings(result)
    return result, version
463 464 465 466

# copy example project (sourceExample is path to project) to temporary directory inside repository
def prepareTemplate(sourceExample):
    templateDir = os.path.abspath(tempDir() + "/template")
467 468 469 470 471
    try:
        shutil.copytree(sourceExample, templateDir)
    except:
        test.fatal("Error while copying '%s' to '%s'" % (sourceExample, templateDir))
        return None
472
    return templateDir
473 474 475 476 477 478 479

def __sortFilenamesOSDependent__(filenames):
    if platform.system() in ('Windows', 'Microsoft'):
        filenames.sort(key=str.lower)
    else:
        filenames.sort()
    return filenames
480

481 482
def __iterateChildren__(model, parent, nestingLevel=0):
    children = []
483
    for currentIndex in dumpIndices(model, parent):
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
        children.append([str(currentIndex.text), nestingLevel])
        if model.hasChildren(currentIndex):
            children.extend(__iterateChildren__(model, currentIndex, nestingLevel + 1))
    return children

# This will write the data to a file which can then be used for comparing
def __writeProjectTreeFile__(projectTree, filename):
    f = open(filename, "w+")
    f.write('"text"\t"nestinglevel"\n')
    for elem in projectTree:
        f.write('"%s"\t"%s"\n' % (elem[0], elem[1]))
    f.close()

def __getTestData__(record):
    return [testData.field(record, "text"),
            __builtin__.int(testData.field(record, "nestinglevel"))]

def compareProjectTree(rootObject, dataset):
    root = waitForObject(rootObject)
    tree = __iterateChildren__(root.model(), root)

    # __writeProjectTreeFile__(tree, dataset)

    for i, current in enumerate(map(__getTestData__, testData.dataset(dataset))):
        try:
            # Just removing everything up to the found item
            # Writing a pass would result in truly massive logs
            tree = tree[tree.index(current) + 1:]
        except ValueError:
            test.fail('Could not find "%s" with nesting level %s' % tuple(current),
                      'Line %s in dataset' % str(i + 1))
            return
    test.passes("No errors found in project tree")
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539

def addCPlusPlusFileToCurrentProject(name, template, forceOverwrite=False):
    if name == None:
        test.fatal("File must have a name - got None.")
        return
    __createProjectOrFileSelectType__("  C++", template, isProject=False)
    window = "{type='Utils::FileWizardDialog' unnamed='1' visible='1'}"
    basePath = str(waitForObject("{type='Utils::BaseValidatingLineEdit' unnamed='1' visible='1' "
                                 "window=%s}" % window).text)
    lineEdit = waitForObject("{name='nameLineEdit' type='Utils::FileNameValidatingLineEdit' "
                             "visible='1' window=%s}" % window)
    replaceEditorContent(lineEdit, name)
    clickButton(waitForObject(":Next_QPushButton"))
    __createProjectHandleLastPage__()
    if (os.path.exists(os.path.join(basePath, name))):
        overwriteDialog = "{type='Core::Internal::PromptOverwriteDialog' unnamed='1' visible='1'}"
        waitForObject(overwriteDialog)
        if forceOverwrite:
            buttonToClick = 'OK'
        else:
            buttonToClick = 'Cancel'
        clickButton("{text='%s' type='QPushButton' unnamed='1' visible='1' window=%s}"
                    % (buttonToClick, overwriteDialog))