project.py 28 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
    mkspec = __getMkspecFromQmake__("qmake")
    test.log("Using mkspec '%s'" % mkspec)

48
    generatorText = "Unix Generator (Desktop 474 GCC)"
49
    if "win32-" in mkspec:
50 51 52
        generatorName = {"win32-g++" : "MinGW Generator (Desktop 474 GCC)",
                         "win32-msvc2008" : "NMake Generator (Desktop 474 MSVC2008)",
                         "win32-msvc2010" : "NMake Generator (Desktop 474 MSVC2010)"}
53
        if mkspec in generatorName:
54 55 56 57 58 59
            generatorText = generatorName[mkspec]
    index = generatorCombo.findText(generatorText)
    if index == -1:
        test.warning("No matching CMake generator for mkspec '%s' found." % mkspec)
    else:
        generatorCombo.setCurrentIndex(index)
60

61
    clickButton(waitForObject(":CMake Wizard.Run CMake_QPushButton"))
Christian Stenger's avatar
Christian Stenger committed
62 63 64 65 66 67 68 69 70 71
    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
72

73 74 75 76
# 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__()
77
def __createProjectOrFileSelectType__(category, template, fromWelcome = False, isProject=True):
78 79 80 81
    if fromWelcome:
        mouseClick(waitForObject(":CreateProject_QStyleItem"), 5, 5, 0, Qt.LeftButton)
    else:
        invokeMenuItem("File", "New File or Project...")
82
    categoriesView = waitForObject("{type='QTreeView' name='templateCategoryView'}")
83 84 85 86
    if isProject:
        clickItem(categoriesView, "Projects." + category, 5, 5, 0, Qt.LeftButton)
    else:
        clickItem(categoriesView, "Files and Classes." + category, 5, 5, 0, Qt.LeftButton)
87
    templatesView = waitForObject("{name='templatesView' type='QListView'}")
88
    clickItem(templatesView, template, 5, 5, 0, Qt.LeftButton)
89
    text = waitForObject("{type='QTextBrowser' name='templateDescription' visible='1'}").plainText
90
    clickButton(waitForObject("{text='Choose...' type='QPushButton' unnamed='1' visible='1'}"))
91
    return __getSupportedPlatforms__(str(text))[0]
92

93
def __createProjectSetNameAndPath__(path, projectName = None, checks = True):
94
    directoryEdit = waitForObject("{type='Utils::BaseValidatingLineEdit' unnamed='1' visible='1'}")
95 96
    replaceEditorContent(directoryEdit, path)
    projectNameEdit = waitForObject("{name='nameLineEdit' visible='1' "
97
                                    "type='Utils::ProjectNameValidatingLineEdit'}")
98 99 100 101 102 103 104 105 106
    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
107
    ensureChecked("{type='QCheckBox' name='projectsDirectoryCheckBox' visible='1'}", False)
108
    clickButton(waitForObject(":Next_QPushButton"))
109
    return str(projectName)
110

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

124
def __createProjectHandleLastPage__(expectedFiles = None):
125
    if expectedFiles != None:
126 127
        summary = str(waitForObject("{name='filesLabel' text?='<qt>Files to be added in<pre>*</pre>'"
                                    "type='QLabel' visible='1'}").text)
128 129 130 131 132 133
        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>")
134
    clickButton(waitForObject("{type='QPushButton' text~='(Finish|Done)' visible='1'}"))
135

136 137 138 139 140 141
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")

142 143 144 145
# 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
146
def createProject_Qt_GUI(path, projectName, checks = True):
147
    template = "Qt Gui Application"
148
    available = __createProjectOrFileSelectType__("  Applications", template)
149
    __createProjectSetNameAndPath__(path, projectName, checks)
150
    checkedTargets = __selectQtVersionDesktop__(checks, available)
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166

    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)

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

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

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

182 183 184 185
# 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
186
def createProject_Qt_Console(path, projectName, checks = True):
187
    available = __createProjectOrFileSelectType__("  Applications", "Qt Console Application")
188
    __createProjectSetNameAndPath__(path, projectName, checks)
189
    checkedTargets = __selectQtVersionDesktop__(checks, available)
190

191 192 193 194 195 196 197
    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"
198 199
        expectedFiles = [path]
        expectedFiles.extend(__sortFilenamesOSDependent__([cpp_file, pro_file]))
200
    __createProjectHandleLastPage__(expectedFiles)
201

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

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

    waitForSignal("{type='CppTools::Internal::CppModelManager' unnamed='1'}", "sourceFilesRefreshed(QStringList)", 10000)
228
    return checkedTargets, projectName
229 230

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

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

# 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'}"
259
                              % QtQuickConstants.getStringForComponents(components))
260 261 262 263 264 265 266 267
    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
268 269
# parameter availableTargets should be the result of __createProjectSelectType__()
#           or use None as a fallback
270 271
def __chooseTargets__(targets=QtQuickConstants.Targets.DESKTOP_474_GCC, availableTargets=None,
                      isMaddeDisabled=True):
272 273 274 275
    if availableTargets != None:
        available = availableTargets
    else:
        # following targets depend on the build environment - added for further/later tests
276
        available = [QtQuickConstants.Targets.DESKTOP_474_GCC,
Christian Stenger's avatar
Christian Stenger committed
277
                     QtQuickConstants.Targets.MAEMO5, QtQuickConstants.Targets.EMBEDDED_LINUX,
278 279
                     QtQuickConstants.Targets.SIMULATOR, QtQuickConstants.Targets.HARMATTAN]
        if platform.system() in ('Windows', 'Microsoft'):
280
            available.remove(QtQuickConstants.Targets.EMBEDDED_LINUX)
Robert Loehning's avatar
Robert Loehning committed
281
            available.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
282 283 284 285
    if isMaddeDisabled:
        for target in filter(lambda x: x in available,
                             (QtQuickConstants.Targets.MAEMO5, QtQuickConstants.Targets.HARMATTAN)):
            available.remove(target)
286
    checkedTargets = []
287 288 289 290
    for current in available:
        mustCheck = targets & current == current
        try:
            ensureChecked("{type='QCheckBox' text='%s' visible='1'}" % QtQuickConstants.getStringForTarget(current),
291
                          mustCheck, 3000)
292 293
            if (mustCheck):
                checkedTargets.append(current)
294 295
        except LookupError:
            if mustCheck:
296 297
                test.fail("Failed to check target '%s'." % QtQuickConstants.getStringForTarget(current))
            else:
298 299 300
                # 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))
301
    return checkedTargets
302 303 304 305 306 307 308 309 310 311 312 313 314 315

# 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
316
    overrideInstallLazySignalHandler()
317 318
    installLazySignalHandler("{type='ProjectExplorer::ApplicationLauncher'}", "processStarted()", "__handleProcessStarted__")
    installLazySignalHandler("{type='ProjectExplorer::ApplicationLauncher'}", "processExited(int)", "__handleProcessExited__")
319
    runButton = waitForObject("{type='Core::Internal::FancyToolButton' text='Run' visible='1'}")
320 321 322 323 324 325 326 327 328 329 330 331 332
    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
333
    if sType == SubprocessType.QT_QUICK_UI and os.getenv("SYSTEST_QMLVIEWER_NO_HOOK_INTO", "0") == "1":
334
        withHookInto = False
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
    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):
358
    ensureChecked(":Qt Creator_AppOutput_Core::Internal::OutputPaneToggleButton")
359 360 361 362
    try:
        waitForObject(":Qt Creator.Stop_QToolButton", 5000)
    except:
        pass
363 364 365 366 367 368 369
    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":
370
            waitFor("stopButton.enabled==False")
371 372 373 374 375 376 377
            snooze(2)
            nativeType("<Escape>")
    else:
        test.fatal("Subprocess does not seem to have been started.")

def __closeSubprocessByHookingInto__(executable, port, function, sType, userDefType):
    global processExited
378
    ensureChecked(":Qt Creator_AppOutput_Core::Internal::OutputPaneToggleButton")
379
    output = waitForObject("{type='Core::OutputWindow' visible='1' windowTitle='Application Output Window'}")
380 381 382 383 384 385 386 387
    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:
        resetApplicationContextToCreator()
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
        if "Loading Qt Wrapper failed" in str(output.plainText):
            test.warning("Loading of Qt Wrapper failed - probably different Qt versions.",
                         "Resetting hook-into settings to continue.")
            # assuming we're still on the build settings of the current project (TODO)
            switchViewTo(ViewConstants.PROJECTS)
            if sType == SubprocessType.QT_QUICK_UI:
                selectConfig = "QML Viewer"
            else:
                selectConfig = executable
            selectFromCombo(waitForObject("{buddy={text='Run configuration:' type='QLabel' "
                                          "unnamed='1' visible='1'} type='QComboBox' unnamed='1' "
                                          "visible='1'}"), selectConfig)
            switchViewTo(ViewConstants.EDIT)
            global processStarted
            processStarted = False
            runButton = waitForObject("{type='Core::Internal::FancyToolButton' text='Run' "
                                      "visible='1'}")
            clickButton(runButton)
            if not waitFor("processStarted == True", 10000):
                test.fatal("Something seems to be really wrong.", "Application output:"
                           % str(output.plainText))
                return False
            else:
                test.log("Application seems to be started without hooking-into.")
        else:
            test.warning("Could not attach to '%s' - using fallback of pushing STOP inside Creator." % executable)
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
        __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)
450 451 452 453 454

# 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
455 456 457 458 459 460 461 462 463
# 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
464 465 466 467
    if 'Supported Platforms' in text:
        supports = text[text.find('Supported Platforms'):].split(":")[1].strip().split(" ")
        result = []
        if 'Desktop' in supports:
468
            result.append(QtQuickConstants.Targets.DESKTOP_474_GCC)
469 470
            if platform.system() in ("Linux", "Darwin"):
                result.append(QtQuickConstants.Targets.EMBEDDED_LINUX)
Robert Loehning's avatar
Robert Loehning committed
471 472
            elif platform.system() in ('Windows', 'Microsoft'):
                result.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
473 474
        if 'MeeGo/Harmattan' in supports:
            result.append(QtQuickConstants.Targets.HARMATTAN)
475
        if 'Maemo/Fremantle' in supports:
476
            result.append(QtQuickConstants.Targets.MAEMO5)
477
        if not re.search("custom Qt Creator plugin", text):
478 479
            result.append(QtQuickConstants.Targets.SIMULATOR)
    elif 'Platform independent' in text:
480
        # MAEMO5 and HARMATTAN could be wrong here - depends on having Madde plugin enabled or not
481
        result = [QtQuickConstants.Targets.DESKTOP_474_GCC, QtQuickConstants.Targets.MAEMO5,
482
                  QtQuickConstants.Targets.SIMULATOR, QtQuickConstants.Targets.HARMATTAN]
Robert Loehning's avatar
Robert Loehning committed
483 484
        if platform.system() in ('Windows', 'Microsoft'):
            result.append(QtQuickConstants.Targets.DESKTOP_474_MSVC2008)
485 486 487
    else:
        test.warning("Returning None (__getSupportedPlatforms__())",
                     "Parsed text: '%s'" % text)
488 489 490 491
        return None, None
    if getAsStrings:
        result = QtQuickConstants.getTargetsAsStrings(result)
    return result, version
492 493 494 495

# copy example project (sourceExample is path to project) to temporary directory inside repository
def prepareTemplate(sourceExample):
    templateDir = os.path.abspath(tempDir() + "/template")
496 497 498 499 500
    try:
        shutil.copytree(sourceExample, templateDir)
    except:
        test.fatal("Error while copying '%s' to '%s'" % (sourceExample, templateDir))
        return None
501
    return templateDir
502 503 504 505 506 507 508

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

510 511
def __iterateChildren__(model, parent, nestingLevel=0):
    children = []
512
    for currentIndex in dumpIndices(model, parent):
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
        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")
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568

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))