← Back to branch summary

~ubuntu-branches/ubuntu/natty/cobertura/natty

« back to all changes in this revision

Viewing changes to examples/functionaltest1/build.xml

  • Committer: Bazaar Package Importer
  • Author(s): Miguel Landaeta
  • Date: 2010-05-11 19:21:46 UTC
  • mfrom: (0.1.4 sid) (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100511192146-j742v5jsl89ztndu
Tags: 1.9.4.1+dfsg-2
http://bugs.debian.org/580842
* Now Build-Depends on libservlet2.5-java and add a missing Depends
  on the same package. (Closes: #580842). 
* Simplify list of JRE dependences for cobertura and drop JRE dependences for
  libcobertura-java as Java libraries are no longer required to depend on a
  JVM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/functionaltest1/build.xml
1
1
<?xml version="1.0" encoding="UTF-8"?>
2
2
 
3
 
<project name="cobertura.examples.functionaltest1" basedir="." default="help">
 
3
<project name="cobertura.examples.functionaltest1" basedir="." default="help" xmlns:cobertura="antlib:net.sourceforge.cobertura.ant">
4
4
 
5
5
        <description>
6
6
    Cobertura - http://cobertura.sourceforge.net/
11
11
    Cobertura comes with ABSOLUTELY NO WARRANTY
12
12
    </description>
13
13
 
 
14
        <!-- Import the Cobertura Ant Library -->
 
15
        <property name="cobertura.local.library" location="../../antLibrary" />
 
16
        <import file="${cobertura.local.library}/library.xml" />
 
17
 
14
18
        <property file="build.properties" />
15
19
        
16
20
        <path id="project.classpath">
21
25
                -->
22
26
                <pathelement location="../../etc" />
23
27
                <pathelement location="../../build/classes" />
 
28
                
 
29
                <pathelement location="../../src" />
24
30
                <fileset dir="../../lib">
25
31
                        <include name="*.jar" />
26
32
                </fileset>
27
33
        </path>
28
34
 
29
 
        <taskdef resource="tasks.properties" classpathref="project.classpath" />
 
35
        <target name="taskdef">
 
36
                <taskdef resource="tasks.properties" classpathref="project.classpath" />
 
37
        </target>
 
38
        
 
39
        <target name="taskdef-antlib">
 
40
                <taskdef 
 
41
                        classpathref="project.classpath"
 
42
                        resource="net/sourceforge/cobertura/ant/antlib.xml"
 
43
                        uri="antlib:net.sourceforge.cobertura.ant" />
 
44
        </target>
30
45
 
31
46
        <target name="help">
32
47
                <echo>This example is only used for testing, and is not meant</echo>
36
51
 
37
52
        <target name="compile">
38
53
                <mkdir dir="${classes.dir}" />
39
 
                <javac srcdir="${src.dir}" destdir="${classes.dir}" debug="true" />
 
54
                <javac srcdir="${src.dir}" destdir="${classes.dir}" debug="true" classpathref="project.classpath" />
40
55
                
41
56
                <rmic 
42
57
                        base="${classes.dir}" 
48
63
                />
49
64
        </target>
50
65
 
51
 
        <target name="instrument-includes-and-excludes" depends="compile">
52
 
                <mkdir dir="${instrumented.dir}" />
53
 
                <cobertura-instrument datafile="${basedir}/cobertura.ser" todir="${instrumented.dir}" classpathref="project.classpath">
54
 
                        <fileset dir="${classes.dir}">
55
 
                                <include name="**/A.class" />
56
 
                                <include name="test/first/RemoteListener*.class" />
57
 
                                <exclude name="**/B.class" />
58
 
                                <exclude name="**/*Test*" />
59
 
                        </fileset>
60
 
                </cobertura-instrument>
61
 
 
62
 
                <path id="test.classpath">
63
 
                        <path location="${instrumented.dir}" />
64
 
                </path>
65
 
        </target>
66
 
 
67
 
        <target name="instrument-classpath" depends="compile">
68
 
                <mkdir dir="${instrumented.dir}" />
69
 
                <cobertura-instrument datafile="${basedir}/cobertura.ser" todir="${instrumented.dir}">
70
 
                        <includeClasses regex="test.*" />
71
 
                        <excludeClasses regex="test.*.B" />
72
 
                        <excludeClasses regex=".*Test*" />
73
 
                        <instrumentationClasspath location="${classes.dir}" />
74
 
                </cobertura-instrument>
75
 
 
76
 
                <path id="test.classpath">
77
 
                        <path location="${instrumented.dir}" />
78
 
                </path>
79
 
        </target>
80
 
 
81
 
        <target name="instrument-war" depends="compile">
82
 
                <property name="tmp.dir" value="${basedir}/tmp" />
 
66
        <target name="instrument-includes-and-excludes" depends="compile,cobertura-groovy-init">
 
67
                <mkdir dir="${instrumented.dir}" />
 
68
                <cobertura:groovy><![CDATA[
 
69
                        //load testUtil definitions
 
70
                        evaluate(new File("${ant.project.baseDir}/../../testUtil.groovy"))
 
71
 
 
72
                        ant."${instrumentTaskName}"(datafile:'${basedir}/cobertura.ser', todir:'${instrumented.dir}', classpathref:'project.classpath') {
 
73
                                fileset(dir:'${classes.dir}') {
 
74
                                        include(name:'**/A.class')
 
75
                                        include(name:'test/first/RemoteListener*.class')
 
76
                                        exclude(name:'**/B.class')
 
77
                                        exclude(name:'**/*Test*')
 
78
                                }
 
79
                        }
 
80
                ]]> </cobertura:groovy>
 
81
 
 
82
                <path id="test.classpath">
 
83
                        <path location="${instrumented.dir}" />
 
84
                </path>
 
85
        </target>
 
86
 
 
87
        <target name="instrument-classpath" depends="compile,cobertura-groovy-init">
 
88
                <mkdir dir="${instrumented.dir}" />
 
89
                <cobertura:groovy><![CDATA[
 
90
                        //load testUtil definitions
 
91
                        evaluate(new File("${ant.project.baseDir}/../../testUtil.groovy"))
 
92
 
 
93
                        ant."${instrumentTaskName}"(datafile:'${basedir}/cobertura.ser', todir:'${instrumented.dir}') {
 
94
                                includeClasses(regex:'test.*')
 
95
                                excludeClasses(regex:'test.*.B')
 
96
                                excludeClasses(regex:'.*Test*')
 
97
                                instrumentationClasspath(location:'${classes.dir}')
 
98
                        }
 
99
                ]]> </cobertura:groovy>
 
100
 
 
101
                <path id="test.classpath">
 
102
                        <path location="${instrumented.dir}" />
 
103
                </path>
 
104
        </target>
 
105
 
 
106
        <target name="instrument-war" depends="compile,cobertura-groovy-init">
 
107
                <property name="tmp" value="tmp" />
 
108
                <property name="tmp.dir" value="${basedir}/${tmp}" />
83
109
                <property name="this.test.work.dir" location="${tmp.dir}/war" />
84
110
                <property name="this.test.wars" location="${tmp.dir}/wars" />
85
111
                <property name="this.test.extract" location="${tmp.dir}/extract" />
112
138
 
113
139
                <!-- Instrument the war file -->
114
140
                <mkdir dir="${instrumented.dir}" />
115
 
                <cobertura-instrument datafile="${basedir}/cobertura.ser" todir="${instrumented.dir}">
116
 
                        <includeClasses regex="test.*" />
117
 
                        <excludeClasses regex="test.*.B" />
118
 
                        <excludeClasses regex=".*Test*" />
119
 
                        <fileset dir="${tmp.dir}">
120
 
                                <include name="app.war" />
121
 
                        </fileset>
122
 
                </cobertura-instrument>
 
141
                <cobertura:groovy><![CDATA[
 
142
                        //load testUtil definitions
 
143
                        evaluate(new File("${ant.project.baseDir}/../../testUtil.groovy"))
 
144
 
 
145
                        ant."${instrumentTaskName}"(datafile:'${basedir}/cobertura.ser', todir:'${instrumented.dir}') {
 
146
                                includeClasses(regex:'test.*')
 
147
                                excludeClasses(regex:'test.*.B')
 
148
                                excludeClasses(regex:'.*Test*')
 
149
                                fileset(dir:'${tmp.dir}') {
 
150
                                        include(name:'app.war')
 
151
                                }
 
152
                        }
 
153
                ]]> </cobertura:groovy>
123
154
 
124
155
                <!-- Unwar and set the classpath to the unwarred stuff -->
125
156
                <unwar src="${instrumented.dir}/app.war" dest="${instrumented.dir}" />
146
177
                </junit>
147
178
        </target>
148
179
 
149
 
        <target name="coverage-reports">
150
 
                <mkdir dir="${coverage.xml.dir}" />
151
 
                <cobertura-report datafile="${basedir}/cobertura.ser" srcdir="${src.dir}" destdir="${coverage.xml.dir}" format="xml" />
152
 
 
153
 
                <mkdir dir="${coverage.html.dir}" />
154
 
                <!-- maxmemory is only specified to test the attribute -->
155
 
                <cobertura-report datafile="${basedir}/cobertura.ser" destdir="${coverage.html.dir}" maxmemory="512M">
156
 
                        <fileset dir="${src.dir}">
157
 
                                <include name="**/*.java" />
158
 
                        </fileset>
159
 
                </cobertura-report>
160
 
        </target>
161
 
 
162
 
        <target name="coverage-check">
163
 
                <cobertura-check branchrate="34" totallinerate="100" />
164
 
        </target>
 
180
        <target name="coverage-reports-only" depends="cobertura-groovy-init">
 
181
                <cobertura:groovy><![CDATA[
 
182
                        //load runReports definition
 
183
                        evaluate(new File("${ant.project.baseDir}/functionalTest.groovy"))
 
184
                        
 
185
                        runReports {
 
186
                                ant.fileset(dir:'${src.dir}', id:'mysrc') {
 
187
                                        include(name:'**/*.java')
 
188
                                }
 
189
                        }
 
190
                ]]> </cobertura:groovy>
 
191
        </target>
 
192
        
 
193
        <target name="coverage-reports" depends="taskdef,coverage-reports-only" />
 
194
        
 
195
        <target name="coverage-reports-with-dirset" depends="cobertura-groovy-init">
 
196
                <cobertura:groovy><![CDATA[
 
197
                        //load runReports definition
 
198
                        evaluate(new File("${ant.project.baseDir}/functionalTest.groovy"))
 
199
                        
 
200
                        runReports {
 
201
                                ant.dirset(dir:'${basedir}', id:'mysrc') {
 
202
                                        include(name:'**/src')
 
203
                                }
 
204
                        }
 
205
                ]]> </cobertura:groovy>
 
206
        </target>
 
207
 
 
208
        <target name="coverage-reports-with-archive" depends="cobertura-groovy-init">
 
209
                <cobertura:groovy><![CDATA[
 
210
                        //load runReports definition
 
211
                        evaluate(new File("${ant.project.baseDir}/functionalTest.groovy"))
 
212
                        
 
213
                        //make a source zip file in the tmp.dir
 
214
                        ant.sequential {
 
215
                                delete(dir:'${tmp.dir}', failonerror:'false')
 
216
                                mkdir(dir:'${tmp.dir}')
 
217
                                zip(destfile:'${tmp.dir}/source.zip', basedir:'${src.dir}')
 
218
                        }
 
219
        
 
220
                        runReports {
 
221
                                ant.dirset(dir:'${basedir}', id:'mysrc') {
 
222
                                        include(name:'${tmp}')
 
223
                                }
 
224
                        }
 
225
                ]]> </cobertura:groovy>
 
226
        </target>
 
227
 
 
228
        <target name="coverage-check-only" depends="cobertura-groovy-init">
 
229
                <cobertura:groovy><![CDATA[
 
230
                        evaluate(new File("${ant.project.baseDir}/functionalTest.groovy"))
 
231
                        
 
232
                        checkRates()
 
233
                        
 
234
                ]]> </cobertura:groovy>
 
235
        </target>
 
236
        
 
237
        <target name="coverage-check" depends="taskdef-antlib,coverage-check-only" />
165
238
 
166
239
        <target name="clean">
167
240
                <delete dir="${classes.dir}" />
172
245
                <delete file="cobertura.ser.lock" />
173
246
        </target>
174
247
 
175
 
        <target name="test-includes-and-excludes" depends="clean,compile,instrument-includes-and-excludes,test,coverage-reports" />
176
 
        <target name="test-classpath" depends="clean,compile,instrument-classpath,test,coverage-reports" />
177
 
        <target name="test-war" depends="clean,compile,instrument-war,test,coverage-reports" />
178
 
        <target name="all" depends="test-includes-and-excludes,test-classpath" />
 
248
        <target name="test-dirset" depends="taskdef-antlib,clean,compile,instrument-includes-and-excludes,test,coverage-reports-with-dirset,coverage-check-only" />
 
249
        <target name="test-includes-and-excludes" depends="taskdef,clean,compile,instrument-includes-and-excludes,test,coverage-reports-only" />
 
250
        <target name="test-classpath" depends="taskdef,clean,compile,instrument-classpath,test,coverage-reports-only" />
 
251
        <target name="test-war" depends="taskdef,clean,compile,instrument-war,test,coverage-reports-with-archive" />
 
252
        <target name="all" depends="taskdef,test-includes-and-excludes,test-classpath" />
179
253
 
180
254
</project>