summaryrefslogtreecommitdiffstatsabout
blob: 531cc0fbda813e0565a5ef1d0e7de713bd088444 (plain)
1
2
3
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
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
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
<?xml version="1.0" encoding="UTF-8"?>
<project
    name="Library"
    default="usage"
    basedir=".">

    <target name="usage">
        <echo message="Please refer to http://wiki.eclipse.org/Platform-releng/Eclipse_Test_Framework for instructions on usage." />
    </target>

    <target
        name="init"
        unless="testframeworkinitialized">
        <!--

            Parameters:

            (Mandatory)

            data-dir    - the directory for Eclipse to write its data

            plugin-name - the name of the plugin to test

            classname   - the name of the test class


            (Optional - added to (or overrides) defaults set in infrastructure scripts)

            vmargs (1)   - a string containing arguments to pass to the VM. These
                           parameters should be specific, but permanent, to the test plugin
                           that uses them. For example, a jdt core test plugin might use
                           vmargs="-DstoreMemory=jdtcoremodel_mem_trace,dir=${basedir}/../..".
                           Note, normally test plugins do not need to specify -Xmx
                           or -XX:MaxPermSize type parameters as they are set by
                           the test infrastructure depending machine, OS, VM version, etc,
                           unless of course the test plugins needs especially low or high values,
                           as part of the test.

            extraVMargs (1) - allows separate setting of VM args in a setting other than
                           the production runs of automated tests. Should not normally be
                           "hard coded" in to the test plugin itself, but instead reserved
                           for someone to add arguments in some other setting other then
                           the production test environment. For example,
                           a committer to jdt.core might want to do a quick test before
                           a commit, and use
                           extraVMargs="-Dcompliance=1.7"
                           in some local version of testing scripts.

            timeout       - overrides default test timeout value (in milliseconds). [May not currently override default?]

            test-output   - overrides default output file produced from test run. [May not currently override default?]

            plugin-path   - path to root of plug-in

            useEclipseExe - property setting forces test to launch via eclipse executable. [Not fully supported. See bug 387638.]

            junit-report-output - output directory for junit reports produced for specified classname.


            (Environment Variables - environment variables that the test framework uses or passes through)

            ANT_OPTS (1)  - Carry through the ANT_OPTS environment variable settings, if any. As described in
                            http://ant.apache.org/manual/running.html
                            <quote>
                            ANT_OPTS - command-line arguments that should be passed to the JVM.
                            For example, you can define system properties or set the
                            maximum Java heap size here.
                            </quote>
                            This can be important for some environments such as running tests on eclipse.org Hudson,
                            where proxy servers, etc., can be defined for that Hudson instance by the machine itself.

            (Reserved -     documented here for awareness, but reserved for use by the test infrastructure
                            itself. The test infrastructure sets these based on typical, common, or required values
                            for the production test environment.)

            frameworkvmargs (1) - vm args provided by the automated test infrastructure. Normally, these arguments
                            provide parameters for cases that apply to all test suites as ran in a production environment,
                            such as -Xms, -Xmx, -XX:MaxPermSize, -XstartOnFirstThread
                            where these values may vary based on machine or VM being used or
                            even type of test (such as, for performance tests, ms and mx are set higher
                            than for unit tests).

            loglocation -   some VMs allow crash log location to specified as VM parameter (but,
                            pretty special, limited usefulness and may be removed.

            Notes:

            1) Note how vm arguments are ordered. The vm arguments variables are combined in order:

              ${frameworkvmargs} ${ANT_OPTS} ${vmargs} ${extraVMargs}

              Typically (as far as is known) if the same argument is specified twice,
              the one appearing last in the line takes priority. For example, if
              vmargs specified -Dtestarg=one and
              extraVMargs specified -Dtestarg=two,
              then "two" could be the value of the testarg property at runtime.

        -->
        <property environment="env" />

        <condition
            property="envantopts"
            value="${env.ANT_OPTS}"
            else="">
            <isset property="env.ANT_OPTS" />
        </condition>


        <echo message="ANT_OPTS: ${env.ANT_OPTS}" />

        <tstamp>
            <format
                property="TIMENOW"
                pattern="HHmmssSSSS" />
        </tstamp>
        <!--property setting useEclipseExe launches tests using the eclipse executable-->
        <condition
            property="launchTarget"
            value="eclipse-test">
            <isset property="useEclipseExe" />
        </condition>
        <!--default launch target for launching tests-->
        <property
            name="launchTarget"
            value="java-test" />
        <property
            name="formatter"
            value="org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter" />

        <!--default heap sizes when running performance tests-->
        <condition
            property="frameworkvmargs"
            value=" -Xms512M -Xmx1024M -XX:MaxPermSize=256m ${envantopts}">
            <equals
                arg1="${test.target}"
                arg2="performance" />
        </condition>
        <tstamp prefix="NOW" />
        <property
            name="coverage-output"
            value="${eclipse-home}/coverage" />
        <property file="${basedir}/finalPluginsVersions.properties" />
        <echo message="basedir = ${basedir}" />
        <property
            name="vmargs"
            value="" />
        <property
            name="extraVMargs"
            value="" />
        <property
            name="plugin-path"
            value="" />
        <property
            name="timeout"
            value="7200000" />
        <property
            name="test-output"
            value="${eclipse-home}/${classname}.xml" />
        <property
            name="junit-report-output"
            value="${eclipse-home}/results" />
        <mkdir dir="${junit-report-output}" />
        <property
            name="junit-stylesheet"
            value="${basedir}/JUNIT.XSL" />
        <property
            name="testframeworkinitialized"
            value="true" />
        <echoproperties description="Echo Properties at end of init in library.xml" />
    </target>

    <target
        name="core-test"
        description="Eclipse application used to launch HEADLESS plugin tests."
        depends="init">
        <antcall target="${launchTarget}">
            <param
                name="application"
                value="org.eclipse.test.coretestapplication" />
        </antcall>
    </target>

    <target
        name="ui-test"
        description="Eclipse application used to launch UI plugin tests."
        depends="init">
        <antcall target="${launchTarget}">
            <param
                name="application"
                value="org.eclipse.test.uitestapplication" />
        </antcall>
    </target>

    <target
        name="java-test"
        depends="init">
        <echo
            level="debug"
            message="DEBUG: Running tests using java-test" />
        <!--default vm args-->
        <condition
            property="frameworkvmargs"
            value=" -Xms40m -Xmx512m -XX:MaxPermSize=256m ${envantopts}">
            <os family="windows" />
        </condition>
        <!--
            For more info on -XstartOnFirstThread, see
            http://stackoverflow.com/questions/3976342/running-swt-based-cross-platform-jar-properly-on-a-mac
        -->
        <condition
            property="frameworkvmargs"
            value=" -XstartOnFirstThread -Xms40m -Xmx512m -XX:MaxPermSize=256m ${envantopts}">
            <os family="mac" />
        </condition>
        <property
            name="frameworkvmargs"
            value=" -Xms40m -Xmx512m -XX:MaxPermSize=256m ${envantopts}" />

        <condition
            property="loglocation"
            value=" ${loglocationarg}=${junit-report-output}/${classname}-crash.log"
            else="">
            <isset property="loglocationarg" />
        </condition>

        <!--set default jvm to use for testing-->
        <property
            name="jvm"
            value="${java.home}/bin/java" />

        <echo message="Running ${classname}. Result file: ${junit-report-output}/${classname}.xml" />
        <echo message="timout property: ${timeout}" />

        <echo message="frameworkvmargs: ${frameworkvmargs}" />
        <echo message="vmargs: ${vmargs}" />
        <echo message="extraVMargs: ${extraVMargs}" />

        <echo message="crash loglocationarg (if any): ${loglocationarg}" />
        <echo message="crash loglocation (if not default): ${loglocation}" />

        <java
            fork="true"
            dir="."
            timeout="${timeout}"
            jvm="${jvm}"
            logError="true"
            classname="org.eclipse.core.launcher.Main"
            output="${junit-report-output}/${classname}.txt">
            <classpath>
                <fileset dir="${eclipse-home}/plugins">
                    <include name="org.eclipse.equinox.launcher_*.jar" />
                </fileset>
            </classpath>
            <arg line="-application ${application}" />
            <arg line="-data ${data-dir}" />
            <arg line="formatter=${formatter},${test-output}" />
            <arg line="-testPluginName ${plugin-name}" />
            <arg line="-className ${classname}" />
            <arg line="-os ${os}" />
            <arg line="-ws ${ws}" />
            <arg line="-arch ${arch}" />
            <arg line="-consolelog" />
            <arg line="-timeout ${timeout}" />
            <arg value="-junitReportOutput" />
            <arg path="${junit-report-output}" />
            <jvmarg line="${frameworkvmargs} ${loglocation} ${vmargs} ${extraVMargs}" />
            <sysproperty
                key="PLUGIN_PATH"
                value="${plugin-path}" />
        </java>
        <antcall target="collect-results" />
    </target>

    <target
        name="eclipse-test"
        description="Runs the specified classname as a plug-in test."
        depends="init">
        <echo
            level="debug"
            message="DEBUG: Running tests using eclipse-test" />
        <property
            name="frameworkvmargs"
            value="-Xms256m -Xmx512m -XX:MaxPermSize=256m" />

        <!--use -consolelog if launching a headless test-->
        <condition
            property="consolelog"
            value="-consolelog">
            <equals
                arg1="${application}"
                arg2="org.eclipse.test.coretestapplication" />
        </condition>
        <property
            name="consolelog"
            value="" />

        <!--
            vm selection priority:
            1.  user-specified java executable via outer Ant property setting of "jvm".
            2.  java executable on path.
        -->
        <condition
            property="test-vm"
            value="-vm ${jvm}">
            <isset property="jvm" />
        </condition>
        <property
            name="test-vm"
            value="" />

        <!--ensure executable has execute permission-->
        <chmod
            file="${eclipse-home}/eclipse"
            perm="ugo+rx" />


        <echo message="Running ${classname}. Result file: ${junit-report-output}/${classname}.xml." />

        <exec
            executable="${eclipse-home}/eclipse"
            dir="${eclipse-home}"
            timeout="${timeout}"
            logError="true"
            failonerror="false"
            output="${junit-report-output}/${classname}.txt">
            <arg line="-data ${data-dir}" />
            <arg line="${test-vm}" />
            <arg line="-application ${application}" />
            <arg line="formatter=${formatter},${test-output}" />
            <arg line="-testPluginName ${plugin-name}" />
            <arg line="-className ${classname}" />
            <arg line="-nosplash" />
            <arg line="--launcher.suppressErrors" />
            <arg line="${consolelog}" />
            <arg line="-vmargs ${frameworkvmargs} ${loglocation} ${vmargs} ${extraVMargs} -DPLUGIN_PATH=${plugin-path}" />
        </exec>
        <antcall target="collect-results" />
    </target>

    <target name="collect-results">
        <dirname
            property="output-dir"
            file="${test-output}" />
        <basename
            property="output-file-name"
            file="${test-output}" />
        <junitreport
            todir="${junit-report-output}"
            tofile="${classname}.xml">
            <fileset dir="${output-dir}">
                <include name="${output-file-name}" />
            </fileset>
        </junitreport>


        <!--save .log content and *.log content from configuration directory-->
        <concat destfile="${junit-report-output}/${classname}.log">
            <fileset
                dir="${eclipse-home}"
                includes="${data-dir}/.metadata/*.log" />
            <fileset
                dir="${eclipse-home}"
                includes="configuration/*.log" />
        </concat>

        <!-- save any crash logs generated (before they are deleted by subsequent test runs -->
        <!--
             TODO: not all VM's call their crash logs "hs_err_pid*.log".
             We can expand the list as we learn of others
        -->
        <copy todir="${junit-report-output}/crashlogs/">
            <fileset dir="${eclipse-home}">
                <include name="**/hs_err_pid*.log" />
            </fileset>
            <globmapper
                from="*"
                to="${classname}.*" />
        </copy>
    </target>

    <target name="collect">
        <!--
            This target can be used to aggragate test runs from multiple test suites into a single report.

            Parameters to this target:
            includes        - the names of the files to include
            output-file        - the name of the output file to produce
        -->
        <junitreport
            todir="."
            tofile="${output-file}">
            <fileset dir=".">
                <include name="${includes}" />
            </fileset>
        </junitreport>
    </target>

</project>