forked from openjdk/jtreg
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathREADME
192 lines (141 loc) · 7.66 KB
/
README
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
Building The Regression Test Harness for the OpenJDK platform: jtreg
(This information is also available at http://openjdk.java.net/jtreg/build.html)
jtreg depends on a number of external components:
JT Harness, TestNG, JUnit, AsmTools. Ant, and JCov.
The fundamental way to build jtreg is with GNU make, specifying where to find
those external components, but a script is also available that will download
appropriate copies of those components before building jtreg.
Building jtreg with the build-all.sh script
This is the recommended way to build jtreg, for those that want a simple,
basic way to build jtreg.
The script is intended to be run in a Unix-like shell, such as bash on Linux or
Mac OS X, or with Cygwin or WSL on Windows. It takes one argument which is the
installation of JDK to be used to build jtreg. In addition, Ant must be on your
execution path as well as a suitable version of Java to run Ant. The version of
JDK must be either JDK 7 or JDK 8.
% cd jtreg-root-directory
% sh make/build-all.sh JDK-directory
The script will create a build sub-directory, download and build dependencies,
and finally build jtreg itself. The resulting image will be in
build/images/jtreg.
No environment variables need to be specified to get a standard build of jtreg.
However, the following environment variables may be set, for a non-standard
build:
ASMTOOLS_VERSION, JCOV_VERSION, JTHARNESS_VERSION
These variables may be set to the name of a tag identifying a specific
changeset in the corresponding OpenJDK repository, or to the pseudo-tag "tip".
MAKE_ARGS
Arguments for the internal invocation of "make". The default is to just build
jtreg, but setting this environment variable allows additional targets, such
as test targets, to be run. The explicit target to build jtreg is "build";
the target to run some basic sanity tests is "quick-test"; and the target
to run all tests is "test". You can also use the make "-j" option to build
targets in parallel. For example:
MAKE_ARGS="-j 4 build quick-test" sh make/build-all.sh
UNZIP_OPTS, WGET_OPTS
These two variables default to "-q", to suppress unnecessary output.
You can set these variables to change the default behavior.
Building jtreg with GNU Make
The Makefile is in make/Makefile, and creates deliverables in the build/
directory, similar to OpenJDK. By default, the build file just builds an image
for jtreg. You can build jtreg from a Unix-like command shell with the following
commands:
% cd <jtreg-root-directory>
% make -C make
Dependencies
jtreg has a number of build dependencies. These can be set with values on the
make command line or with values in make/Defs.gmk. You can also include the
appropriate license files in the jtreg image, by setting the appropriate make
variables. These are documented in make/Defs.gmk
JDK 1.7 (or better)
Set JDKHOME to the JDK or equivalent used to build jtreg. It must be
equivalent to JDK 1.7 or later.
JT Harness
See https://wiki.openjdk.java.net/display/CodeTools/JT+Harness.
Set JTHARNESS_HOME to the installed copy of the version of JT Harness to be
used. It should be version 5.0 or better.
Ant
See http://ant.apache.org/. Set ANTHOME to an installed copy of Ant. It
should be version 1.9.x. or better.
AsmTools
See https://wiki.openjdk.java.net/display/CodeTools/asmtools.
Set ASMTOOLS_HOME to the installed copy of the version of AsmTools to be
used. It should be version 6.0 or better.
Note: Do not confuse this component with ASM bytecode engineering library
available at http://asm.ow2.org/
JUnit
See http://junit.org/. The recommended version is currently JUnit 4.10.
TestNG
See http://testng.org/. The recommended version is currently 6.9.5.
The following dependencies are optional.
JCov
See https://wiki.openjdk.java.net/display/CodeTools/jcov.
Set JCOV_HOME to the installed copy of the version of JCov to be used.
It should be version 2.0 or better.
JDK 1.5
This is used when running some of the tests. Set JDK15HOME to run these
tests. It need not be set if you are just building jtreg.
JDK 1.6
This is used when running some of the tests. Set JDK16HOME to run these
tests. It need not be set if you are just building jtreg.
JDK 1.7
This is used when running some of the tests. Set JDK17HOME to run these
tests. It need not be set if you are just building jtreg.
JDK 1.8
This is used when running some of the tests. Set JDK18HOME to run these
tests. It need not be set if you are just building jtreg.
JDK 1.9
This is used when running some of the tests. Set JDK19HOME to run these
tests. It need not be set if you are just building jtreg.
Running jtreg Self-Tests
The tests can be invoked with individual make targets, or collectively via the
"test" target.
Some of the tests need to pop up windows while they execute. No interaction with
these windows is normally required. Since this can be a problem on a headless
server machine, and an annoyance on a personal workstation, the tests will
attempt to use VNC to create a dummy X-server for use by the tests while they
are running. Various implementations of VNC are available, such as from
http://www.realvnc.com/. Using VNC is optional; it is not required in order to
run the tests.
By default, VNC will be used if vncserver is found on your execution path, or
if VNC_HOME points to an installed copy of VNC. To explicitly disable the use of
VNC, set the VNC environment variable to one of false, off, no, or 0. Unless
explicitly disabled, the tests will check the following:
* You must have a password set in $HOME/.vnc/passwd. This is the standard
location used by the vncserver command.
* If you set the environment variable VNC_HOME, it will be prepended to your
execution path to find vncserver.
* vncserver must be on your execution path, after VNC_HOME has been added,
if set.
If the tests find any issue with using VNC, it will not be used. If VNC is used
to create a dummy X server, the server will be terminated when the test is
complete.
The logic for using VNC is encapsulated within the script make/display.sh.
Building jtreg with Ant
It is possible to build jtreg with Ant, but this is primarily intended as a
convenience while working on the jtreg source code. If you are building jtreg
to run OpenJDK tests, it is recommended that you build jtreg using the Makefile,
perhaps via the build-all.sh wrapper script.
The build file is in make/build.xml; it creates intermediate files in the build/
directory and deliverables in the dist/ directory. By default, the build file
just builds jtreg, but does not run any tests. You can build jtreg from a
Unix-like command shell with the following commands:
% cd jtreg-root-directory
% ant -f make/build.xml
You can also use this build file when creating a NetBeans free form project with
an existing build file.
Dependencies
Some of the tasks that are used are listed as "Optional Tasks" in the Ant
manual. You may need to make sure that these tasks are available for use by Ant.
For example, on Ubuntu Linux these tasks are in the ant-optional package.
Running Tests
Some of the tests can be invoked with individual targets beginning
"-jtreg-test-", or collectively via the "jtreg-test" target. (The use of
"jtreg-test" rather than "test" is to protect against interactions with JUnit in
older versions of NetBeans.)
Using the IntelliJ IDE
The jtreg repo also contains a plugin for the IntelliJ IDE.
This is a convenience plugin which adds jtreg capabilities to the IntelliJ IDE.
With this plugin, OpenJDK developers can write, run, and debug jtreg tests
without leaving their IDE environment. For more details, see the file
`plugins/idea/README.md` in this repo.