build_utils.py 11.5 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
31
import re;

32
33
34
35
# flag to indicate whether a tasks file should be created when building ends with errors
createTasksFileOnError = True

# this method checks the last build (if there's one) and logs the number of errors, warnings and
36
# lines within the Issues output
37
38
39
40
41
42
43
44
# optional parameter can be used to tell this function if the build was expected to fail or not
def checkLastBuild(expectedToFail=False):
    try:
        # can't use waitForObject() 'cause visible is always 0
        buildProg = findObject("{type='ProjectExplorer::Internal::BuildProgress' unnamed='1' }")
    except LookupError:
        test.log("checkLastBuild called without a build")
        return
45
46
47
48
49
50
    ensureChecked(":Qt Creator_Issues_Core::Internal::OutputPaneToggleButton")
    model = waitForObject(":Qt Creator.Issues_QListView").model()
    buildIssues = dumpBuildIssues(model)
    errors = len(filter(lambda i: i[5] == "1", buildIssues))
    warnings = len(filter(lambda i: i[5] == "2", buildIssues))
    gotErrors = errors != 0
51
52
    if not (gotErrors ^ expectedToFail):
        test.passes("Errors: %s | Warnings: %s" % (errors, warnings))
53
    else:
54
        test.fail("Errors: %s | Warnings: %s" % (errors, warnings))
55
    # additional stuff - could be removed... or improved :)
56
    test.log("Rows inside issues: %d" % model.rowCount())
57
    if gotErrors and createTasksFileOnError:
58
        createTasksFile(buildIssues)
59
60
    return not gotErrors

61
62
# helper function to check the compilation when build wasn't successful
def checkCompile():
63
    ensureChecked(":Qt Creator_CompileOutput_Core::Internal::OutputPaneToggleButton")
64
    output = waitForObject(":Qt Creator.Compile Output_Core::OutputWindow")
65
    waitFor("len(str(output.plainText))>0",5000)
66
    if compileSucceeded(output.plainText):
67
68
        if os.getenv("SYSTEST_DEBUG") == "1":
            test.log("Compile Output:\n%s" % output.plainText)
69
70
        test.passes("Compile successful")
        return True
71
    else:
72
        test.fail("Compile Output:\n%s" % output.plainText)
73
74
75
76
77
        return False

def compileSucceeded(compileOutput):
    return None != re.match(".*exited normally\.\n\d\d:\d\d:\d\d: Elapsed time: "
                            "(\d:)?\d{2}:\d\d\.$", str(compileOutput), re.S)
78

79
def waitForCompile(timeout=60000):
80
    progressBarWait(10000) # avoids switching to Issues pane after checking Compile Output
81
82
83
84
85
    ensureChecked(":Qt Creator_CompileOutput_Core::Internal::OutputPaneToggleButton")
    output = waitForObject(":Qt Creator.Compile Output_Core::OutputWindow")
    if not waitFor("re.match('.*Elapsed time: (\d:)?\d{2}:\d\d\.$', str(output.plainText), re.S)", timeout):
        test.warning("Waiting for compile timed out after %d s." % (timeout / 1000))

86
87
88
89
90
91
92
93
def dumpBuildIssues(listModel):
    issueDump = []
    for row in range(listModel.rowCount()):
        index = listModel.index(row, 0)
        issueDump.extend([map(lambda role: index.data(role).toString(),
                              range(Qt.UserRole, Qt.UserRole + 6))])
    return issueDump

94
95
96
# counter for written tasks files
tasksFileCount = 0

97
98
# helper method that writes a tasks file
def createTasksFile(buildIssues):
99
100
101
    # currently used directory for tasks files
    tasksFileDir = None
    global tasksFileCount
102
    if tasksFileDir == None:
103
104
105
106
107
108
109
110
111
            tasksFileDir = os.getcwd() + "/tasks"
            tasksFileDir = os.path.abspath(tasksFileDir)
    if not os.path.exists(tasksFileDir):
        try:
            os.makedirs(tasksFileDir)
        except OSError:
            test.log("Could not create %s - falling back to a temporary directory" % tasksFileDir)
            tasksFileDir = tempDir()

112
113
114
115
    tasksFileCount += 1
    outfile = os.path.join(tasksFileDir, os.path.basename(squishinfo.testCase)+"_%d.tasks" % tasksFileCount)
    file = codecs.open(outfile, "w", "utf-8")
    test.log("Writing tasks file - can take some time (according to number of issues)")
116
    rows = len(buildIssues)
117
118
119
120
    if os.environ.get("SYSTEST_DEBUG") == "1":
        firstrow = 0
    else:
        firstrow = max(0, rows - 100)
121
    for issue in buildIssues[firstrow:rows]:
122
        # the following is currently a bad work-around
123
124
125
126
        fData = issue[0] # file
        lData = issue[1] # line -> linenumber or empty
        tData = issue[5] # type -> 1==error 2==warning
        dData = issue[3] # description
127
128
129
130
131
132
133
134
        if lData == "":
            lData = "-1"
        if tData == "1":
            tData = "error"
        elif tData == "2":
            tData = "warning"
        else:
            tData = "unknown"
135
        if str(fData).strip() == "" and lData == "-1" and str(dData).strip() == "":
136
            test.fatal("Found empty task.")
137
138
139
140
        file.write("%s\t%s\t%s\t%s\n" % (fData, lData, tData, dData))
    file.close()
    test.log("Written tasks file %s" % outfile)

141
142
143
# returns a list of pairs each containing the zero based number of a kit
# and the name of the matching build configuration
# param kitCount specifies the number of kits currently defined (must be correct!)
144
# param filter is a regular expression to filter the configuration by their name
145
def iterateBuildConfigs(kitCount, filter = ""):
146
    switchViewTo(ViewConstants.PROJECTS)
147
148
149
    configs = []
    for currentKit in range(kitCount):
        switchToBuildOrRunSettingsFor(kitCount, currentKit, ProjectSettings.BUILD)
150
        model = waitForObject(":scrollArea.Edit build configuration:_QComboBox").model()
151
152
153
154
155
156
        prog = re.compile(filter)
        # for each row in the model, write its data to a list
        configNames = dumpItems(model)
        # pick only those configuration names which pass the filter
        configs += zip([currentKit] * len(configNames),
                       [config for config in configNames if prog.match(config)])
157
158
159
160
161
162
163
    switchViewTo(ViewConstants.EDIT)
    return configs

# selects a build configuration for building the current project
# param targetCount specifies the number of targets currently defined (must be correct!)
# param currentTarget specifies the target for which to switch into the specified settings (zero based index)
# param configName is the name of the configuration that should be selected
164
# param afterSwitchTo the ViewConstant of the mode to switch to after selecting or None
165
# returns information about the selected kit, see getQtInformationForBuildSettings
166
def selectBuildConfig(targetCount, currentTarget, configName, afterSwitchTo=ViewConstants.EDIT):
167
168
    switchViewTo(ViewConstants.PROJECTS)
    switchToBuildOrRunSettingsFor(targetCount, currentTarget, ProjectSettings.BUILD)
169
170
    selectFromCombo(":scrollArea.Edit build configuration:_QComboBox", configName)
    progressBarWait(30000)
171
    return getQtInformationForBuildSettings(targetCount, True, afterSwitchTo)
172

173
# This will not trigger a rebuild. If needed, caller has to do this.
174
175
def verifyBuildConfig(targetCount, currentTarget, configName, shouldBeDebug=False, enableShadowBuild=False, enableQmlDebug=False):
    qtInfo = selectBuildConfig(targetCount, currentTarget, configName, None)
176
    ensureChecked(waitForObject(":scrollArea.Details_Utils::DetailsButton"))
177
178
    ensureChecked("{name='shadowBuildCheckBox' type='QCheckBox' visible='1'}", enableShadowBuild)
    buildCfCombo = waitForObject("{type='QComboBox' name='buildConfigurationComboBox' visible='1' "
179
                                 "window=':Qt Creator_Core::Internal::MainWindow'}")
180
181
182
183
    if shouldBeDebug:
        test.compare(buildCfCombo.currentText, 'Debug', "Verifying whether it's a debug build")
    else:
        test.compare(buildCfCombo.currentText, 'Release', "Verifying whether it's a release build")
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
    if enableQmlDebug:
        try:
            libLabel = waitForObject(":scrollArea.Library not available_QLabel", 2000)
            mouseClick(libLabel, libLabel.width - 10, libLabel.height / 2, 0, Qt.LeftButton)
        except:
            pass
        # Since waitForObject waits for the object to be enabled,
        # it will wait here until compilation of the debug libraries has finished.
        qmlDebugCheckbox = waitForObject(":scrollArea.qmlDebuggingLibraryCheckBox_QCheckBox", 150000)
        if qmlDebugCheckbox.checked != enableQmlDebug:
            clickButton(qmlDebugCheckbox)
            # Don't rebuild now
            clickButton(waitForObject(":QML Debugging.No_QPushButton", 5000))
        try:
            problemFound = waitForObject("{window=':Qt Creator_Core::Internal::MainWindow' "
                                         "type='QLabel' name='problemLabel' visible='1'}", 1000)
            if problemFound:
                test.warning('%s' % problemFound.text)
        except:
            pass
    else:
        qmlDebugCheckbox = findObject(":scrollArea.qmlDebuggingLibraryCheckBox_QCheckBox")
        if qmlDebugCheckbox.enabled and qmlDebugCheckbox.checked:
            test.log("Qml debugging libraries are available - unchecking qml debugging.")
            clickButton(qmlDebugCheckbox)
            # Don't rebuild now
            clickButton(waitForObject(":QML Debugging.No_QPushButton", 5000))
211
    clickButton(waitForObject(":scrollArea.Details_Utils::DetailsButton"))
212
    switchViewTo(ViewConstants.EDIT)
213
    return qtInfo
214
215
216
217
218
219
220
221

# verify if building and running of project was successful
def verifyBuildAndRun():
    # check compile output if build successful
    checkCompile()
    # check application output log
    appOutput = logApplicationOutput()
    if appOutput:
222
223
        test.verify((re.search(".* exited with code \d+", str(appOutput)) or
                     re.search("The program has unexpectedly finished\.", str(appOutput))) and
224
225
226
227
228
229
230
231
232
233
234
235
236
237
                    re.search('[Ss]tarting.*', str(appOutput)),
                    "Verifying if built app started and closed successfully.")

# run project for debug and release
def runVerify(checkedTargets):
    availableConfigs = iterateBuildConfigs(len(checkedTargets))
    if not availableConfigs:
        test.fatal("Haven't found build configurations, quitting")
        invokeMenuItem("File", "Save All")
        invokeMenuItem("File", "Exit")
    # select debug configuration
    for kit, config in availableConfigs:
        selectBuildConfig(len(checkedTargets), kit, config)
        test.log("Using build config '%s'" % config)
238
239
240
        if runAndCloseApp() == None:
            checkCompile()
            continue
241
242
        verifyBuildAndRun()
        mouseClick(waitForObject(":*Qt Creator.Clear_QToolButton"))