1 #
   2 # Makefile to run jtreg and other tests
   3 #
   4 
   5 # Product builds and langtools builds
   6 #
   7 # A full product build (or "control" build) creates a complete JDK image.
   8 # To test a product build, set TESTJAVA to the path for the image.
   9 #
  10 # A langtools build just builds the langtools components of a JDK.
  11 # To test a langtools build, set TESTJAVA to the path for a recent JDK
  12 # build, and set TESTBOOTCLASSPATH to the compiled langtools classes --
  13 # for example build/classes or dist/lib/classes.jar.
  14 
  15 # JPRT
  16 # JPRT may invoke this Makefile directly, as part of a langtools build,
  17 # or indirectly, via FOREST/test/Makefile, as part of a control build.
  18 
  19 # Get OS/ARCH specifics
  20 OSNAME = $(shell uname -s)
  21 ifeq ($(OSNAME), SunOS)
  22   SLASH_JAVA = /java
  23   PLATFORM = solaris
  24   JT_PLATFORM = solaris
  25   ARCH = $(shell uname -p)
  26   ifeq ($(ARCH), i386)
  27     ARCH=i586
  28   endif
  29 endif
  30 ifeq ($(OSNAME), Linux)
  31   SLASH_JAVA = /java
  32   PLATFORM = linux
  33   JT_PLATFORM = linux
  34   ARCH = $(shell uname -m)
  35   ifeq ($(ARCH), i386)
  36     ARCH=i586
  37   endif
  38 endif
  39 ifeq ($(OSNAME), Darwin)
  40   PLATFORM = bsd
  41   JT_PLATFORM = linux
  42   ARCH = $(shell uname -m)
  43   ifeq ($(ARCH), i386)
  44     ARCH=i586
  45   endif
  46 endif
  47 ifeq ($(OSNAME), Windows_NT)
  48   # MKS
  49   PLATFORM=windows
  50 endif
  51 ifeq ($(PLATFORM),)
  52   PLATFORM = windows
  53   CYGPATH = | cygpath -m -s -f -
  54 endif
  55 
  56 ifeq ($(PLATFORM), windows)
  57   SLASH_JAVA = J:
  58   JT_PLATFORM = win32
  59   ifeq ($(word 1, $(PROCESSOR_IDENTIFIER)),ia64)
  60     ARCH=ia64
  61   else
  62     ifeq ($(word 1, $(PROCESSOR_IDENTIFIER)),AMD64)
  63       ARCH=x64
  64     else
  65       ifeq ($(word 1, $(PROCESSOR_IDENTIFIER)),EM64T)
  66         ARCH=x64
  67       else
  68         ARCH=i586
  69       endif
  70     endif
  71   endif
  72   EXE_SUFFIX=.exe
  73 endif
  74 
  75 # Root of this test area (important to use full paths in some places)
  76 TEST_ROOT := $(shell pwd $(CYGPATH) )
  77 
  78 # Default bundle of all test results (passed or not) (JPRT only)
  79 ifdef JPRT_JOB_ID
  80   JPRT_CLEAN = clean
  81   JPRT_ARCHIVE_BUNDLE = $(TEST_ROOT)/JPRT_ARCHIVE_BUNDLE.zip
  82 endif
  83 
  84 ifeq ($(PLATFORM), windows)
  85   SLASH_JAVA = J:
  86 else
  87   SLASH_JAVA = /java
  88 endif
  89 
  90 # Default JTREG to run
  91 ifdef JPRT_JTREG_HOME
  92   JTREG_HOME = $(JPRT_JTREG_HOME)
  93 else
  94   JTREG_HOME = $(SLASH_JAVA)/re/jtreg/4.1/promoted/latest/binaries/jtreg
  95 endif
  96 JTREG = $(JTREG_HOME)/$(JT_PLATFORM)/bin/jtreg
  97 JTDIFF = $(JTREG_HOME)/$(JT_PLATFORM)/bin/jtdiff
  98 
  99 # Default JCK to run
 100 ifdef JPRT_JCK_HOME
 101   JCK_HOME = $(JPRT_JCK_HOME)
 102 else
 103   JCK_HOME = $(SLASH_JAVA)/re/jck/8/promoted/latest/binaries
 104 endif
 105 
 106 # Default JDK for JTREG and JCK
 107 #
 108 # JT_JAVA is the version of java used to run jtreg/JCK. Since it is now
 109 # standard to execute tests in sameVM mode, it should normally be set the
 110 # same as TESTJAVA (although not necessarily so.)
 111 #
 112 ifdef JPRT_JAVA_HOME
 113   JT_JAVA = $(JPRT_JAVA_HOME)
 114 else
 115   JT_JAVA = $(SLASH_JAVA)/re/jdk/1.7.0/archive/fcs/binaries/$(PLATFORM)-$(ARCH)
 116 endif
 117 
 118 # Default JDK to test
 119 ifdef JPRT_IMPORT_PRODUCT_HOME
 120   TESTJAVA = $(JPRT_IMPORT_PRODUCT_HOME)
 121 else
 122   TESTJAVA = $(SLASH_JAVA)/re/jdk/1.7.0/promoted/latest/binaries/$(PLATFORM)-$(ARCH)
 123 endif
 124 
 125 # PRODUCT_HOME is a JPRT variable pointing to a directory containing the output from
 126 # make/Makefile
 127 # For langtools, this is a directory containing build and dist
 128 # For a control build, this is build/$(PRODUCT)-$(ARCH)/XYZ-image
 129 #       (i.e, j2sdk-image or jdk-module-image)
 130 ifdef PRODUCT_HOME
 131   ifeq ($(shell [ -r $(PRODUCT_HOME)/dist/lib/classes.jar ]; echo $$?),0)
 132     TESTBOOTCLASSPATH = $(PRODUCT_HOME)/dist/lib/classes.jar
 133   endif
 134   ifeq ($(shell [ -r $(PRODUCT_HOME)/bin/javac$(EXE_SUFFIX) ]; echo $$?),0)
 135     TESTJAVA = $(PRODUCT_HOME)
 136   endif
 137 endif
 138 
 139 ifdef TESTBOOTCLASSPATH
 140   JTREG_OPTIONS += -Xbootclasspath/p:$(TESTBOOTCLASSPATH)
 141 ### In the following, -refvmoptions is an undocumented option
 142 ### The following does not work JCK 7 b30 2/6/2010. Awaiting b31.
 143   JCK_OPTIONS += \
 144         -vmoptions:-Xbootclasspath/p:$(TESTBOOTCLASSPATH) \
 145         -refvmoptions:-Xbootclasspath/p:$(TESTBOOTCLASSPATH)
 146 endif
 147 
 148 # Concurrency is the number of tests that can execute at once.
 149 # On an otherwise empty machine, suggest setting to (#cpus + 2)
 150 # If unset, the default is (#cpus)
 151 ### RFE: determine and use #cpus
 152 ifdef CONCURRENCY
 153   JTREG_OPTIONS += -agentvm -concurrency:$(CONCURRENCY)
 154 else
 155   JTREG_OPTIONS += -samevm
 156 endif
 157 
 158 ifdef JCK_CONCURRENCY
 159   JCK_OPTIONS += -concurrency:$(JCK_CONCURRENCY)
 160 endif
 161 
 162 # JCK is executed using "Multi-JVM Group Mode", which is a hybrid
 163 # of otherVM and sameVM modes. New JVMs are created and reused for
 164 # a number of tests, then eventually discarded and a new one started.
 165 # This amortizes the JVM startup time.  The "group size" defines
 166 # how many tests are run in a JVM before it is replaced.
 167 # If unset, the default is 100.
 168 JCK_GROUP_SIZE = 1000
 169 ifdef JCK_GROUP_SIZE
 170   JCK_COMPILER_OPTIONS += \
 171     -jtoptions:-Ejck.env.compiler.testCompile.groupMode.groupSize=$(JCK_GROUP_SIZE) \
 172     -jtoptions:-Ejck.env.compiler.compRefExecute.groupMode.groupSize=$(JCK_GROUP_SIZE)
 173 ### The following is not supported. Awaiting RFE 6924287
 174 ### 6924287: Jck4Jdk: Allow to configure test group size for group mode via simple command line option
 175 ###  JCK_RUNTIME_OPTIONS += \
 176 ###    -jtoptions:-Ejck.env.runtime.testCompile.groupMode.groupSize=$(JCK_GROUP_SIZE)
 177 endif
 178 
 179 # Timeouts -- by default, increase test timeouts when running on JPRT
 180 ifdef JPRT_JOB_ID
 181   ifndef JTREG_TIMEOUT_FACTOR
 182     JTREG_TIMEOUT_FACTOR = 3
 183   endif
 184 endif
 185 ifdef JTREG_TIMEOUT_FACTOR
 186   JTREG_OPTIONS += -timeoutFactor:$(JTREG_TIMEOUT_FACTOR)
 187 endif
 188 
 189 # Assertions: some tests show failures when assertions are enabled.
 190 # Since javac is typically loaded via the bootclassloader (either via TESTJAVA
 191 # or TESTBOOTCLASSPATH), you may need -esa to enable assertions in javac.
 192 JTREG_OPTIONS += $(ASSERTION_OPTIONS)
 193 JCK_OPTIONS += $(ASSERTION_OPTIONS:%=-vmoptions:%)
 194 
 195 # Include shared options
 196 JCK_COMPILER_OPTIONS += $(JCK_OPTIONS)
 197 JCK_RUNTIME_OPTIONS += $(JCK_OPTIONS)
 198 
 199 # Exit codes:
 200 # jtreg, jck:   0: OK, 1: tests failed, 2: tests error; 3+: SERIOUS
 201 FATAL_JTREG_EXIT = 3
 202 FATAL_JCK_EXIT = 3
 203 # jtdiff: 0: OK, 1: differences found; 2+: SERIOUS
 204 FATAL_JTDIFF_EXIT = 2
 205 #
 206 # Exit -- used for final "normal" exit from "make". Redefine to "true" to avoid
 207 # having make exit with non-zero return code.
 208 EXIT = exit
 209 # Function to exit shell if exit code of preceding command is greater than or equal
 210 # to a given level. Redefine function or preceding FATAL_*_EXIT codes as needed.
 211 EXIT_IF_FATAL = status=$$?; if [ $$status -ge $(1) ]; then exit $$status ; fi
 212 
 213 # The test directories to run
 214 DEFAULT_TESTDIRS = .
 215 TESTDIRS = $(DEFAULT_TESTDIRS)
 216 
 217 # Root of all test results
 218 TEST_OUTPUT_DIR = $(TEST_ROOT)/../build/$(PLATFORM)-$(ARCH)/test/langtools
 219 ABS_TEST_OUTPUT_DIR := \
 220         $(shell mkdir -p $(TEST_OUTPUT_DIR); \
 221                 cd  $(TEST_OUTPUT_DIR); \
 222                 pwd $(CYGPATH))
 223 # Subdirectories for different test runs
 224 JTREG_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jtreg
 225 JCK_COMPILER_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jck-compiler
 226 JCK_RUNTIME_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jck-runtime-Xcompile
 227 
 228 # Default make rule -- warning, may take a while
 229 all: $(JPRT_CLEAN) jtreg-tests jck-compiler-tests jck-runtime-tests $(JPRT_ARCHIVE_BUNDLE) all-summary
 230         @echo "Testing completed successfully"
 231 
 232 jtreg apt javac javadoc javah javap jdeps: $(JPRT_CLEAN) jtreg-tests $(JPRT_ARCHIVE_BUNDLE) jtreg-summary
 233         @echo "Testing completed successfully"
 234 
 235 jck-compiler: $(JPRT_CLEAN) jck-compiler-tests $(JPRT_ARCHIVE_BUNDLE) jck-compiler-summary
 236         @echo "Testing completed successfully"
 237 
 238 jck-runtime: $(JPRT_CLEAN) jck-runtime-tests $(JPRT_ARCHIVE_BUNDLE) jck-runtime-summary
 239         @echo "Testing completed successfully"
 240 
 241 # for use with JPRT -testrule
 242 all:            JTREG_TESTDIRS = .
 243 jtreg:          JTREG_TESTDIRS = .
 244 apt:            JTREG_TESTDIRS = tools/apt
 245 javac:          JTREG_TESTDIRS = tools/javac
 246 javadoc:        JTREG_TESTDIRS = tools/javadoc com/sun/javadoc
 247 javah:          JTREG_TESTDIRS = tools/javah
 248 javap:          JTREG_TESTDIRS = tools/javap
 249 jdeps:          JTREG_TESTDIRS = tools/jdeps
 250 
 251 # Run jtreg tests
 252 #
 253 # JTREG_HOME
 254 #       Installed location of jtreg
 255 # JT_JAVA
 256 #       Version of java used to run jtreg.  Should normally be the same as TESTJAVA
 257 # TESTJAVA
 258 #       Version of java to be tested.
 259 # JTREG_OPTIONS
 260 #       Additional options for jtreg
 261 # JTREG_TESTDIRS
 262 #       Directories of tests to be run
 263 # JTREG_OUTPUT_DIR
 264 #       Where to write the results
 265 # JTREG_REFERENCE
 266 #       (Optional) reference results (e.g. work, report or summary.txt)
 267 #
 268 jtreg_tests: jtreg-tests
 269 jtreg-tests: check-jtreg FRC
 270         @rm -f -r $(JTREG_OUTPUT_DIR)/JTwork $(JTREG_OUTPUT_DIR)/JTreport \
 271             $(JTREG_OUTPUT_DIR)/diff.html $(JTREG_OUTPUT_DIR)/status.txt
 272         @mkdir -p $(JTREG_OUTPUT_DIR)
 273         JT_JAVA=$(JT_JAVA) $(JTREG) \
 274           -J-Xmx512m \
 275           -vmoption:-Xmx768m \
 276           -a -ignore:quiet -v:fail,error,nopass \
 277           -r:$(JTREG_OUTPUT_DIR)/JTreport \
 278           -w:$(JTREG_OUTPUT_DIR)/JTwork \
 279           -jdk:$(TESTJAVA) \
 280           $(JAVA_ARGS:%=-vmoption:%) \
 281           $(JTREG_OPTIONS) \
 282           $(JTREG_TESTDIRS) \
 283         || ( $(call EXIT_IF_FATAL,$(FATAL_JTREG_EXIT)) ; \
 284             echo $$status > $(JTREG_OUTPUT_DIR)/status.txt \
 285         )
 286 ifdef JTREG_REFERENCE
 287         JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JTREG_OUTPUT_DIR)/diff.html \
 288             $(JTREG_REFERENCE) $(JTREG_OUTPUT_DIR)/JTreport \
 289         || ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )
 290 endif
 291 
 292 jtreg-summary: FRC
 293         if [ -r $(JTREG_OUTPUT_DIR)/status.txt ]; then \
 294             echo ; echo "Summary of jtreg test failures" ; \
 295             cat $(JTREG_OUTPUT_DIR)/JTreport/text/summary.txt | \
 296                 grep -v 'Not run' | grep -v 'Passed' ; \
 297             echo ; \
 298             $(EXIT) `cat $(JTREG_OUTPUT_DIR)/status.txt` ; \
 299         fi
 300 
 301 # Check to make sure these directories exist
 302 check-jtreg: $(PRODUCT_HOME) $(JTREG)
 303 
 304 
 305 # Run JCK-compiler tests
 306 #
 307 # JCK_HOME
 308 #       Installed location of JCK: should include JCK-compiler, and JCK-extras
 309 #       Default is JCK 8.
 310 # JT_JAVA
 311 #       Version of java used to run JCK.  Should normally be the same as TESTJAVA
 312 #       Default is JDK 7
 313 # TESTJAVA
 314 #       Version of java to be tested.
 315 # JCK_COMPILER_OPTIONS
 316 #       Additional options for JCK-compiler
 317 # JCK_COMPILER_TESTDIRS
 318 #       Directories of tests to be run
 319 # JCK_COMPILER_OUTPUT_DIR
 320 #       Where to write the results
 321 # JCK_COMPILER_REFERENCE
 322 #       (Optional) reference results (e.g. work, report or summary.txt)
 323 #
 324 jck-compiler-tests: check-jck FRC
 325         @rm -f -r $(JCK_COMPILER_OUTPUT_DIR)/work $(JCK_COMPILER_OUTPUT_DIR)/report \
 326             $(JCK_COMPILER_OUTPUT_DIR)/diff.html $(JCK_COMPILER_OUTPUT_DIR)/status.txt
 327         @mkdir -p $(JCK_COMPILER_OUTPUT_DIR)
 328         $(JT_JAVA)/bin/java -XX:MaxPermSize=256m -Xmx512m \
 329             -jar $(JCK_HOME)/JCK-compiler-8/lib/jtjck.jar \
 330             -v:non-pass \
 331             -r:$(JCK_COMPILER_OUTPUT_DIR)/report \
 332             -w:$(JCK_COMPILER_OUTPUT_DIR)/work \
 333             -jdk:$(TESTJAVA) \
 334             $(JCK_COMPILER_OPTIONS) \
 335             $(JCK_COMPILER_TESTDIRS) \
 336         || ( $(call EXIT_IF_FATAL,$(FATAL_JCK_EXIT)) ; \
 337             echo $$status > $(JCK_COMPILER_OUTPUT_DIR)/status.txt \
 338         )
 339 ifdef JCK_COMPILER_REFERENCE
 340         JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JCK_COMPILER_OUTPUT_DIR)/diff.html \
 341             $(JCK_COMPILER_REFERENCE) $(JCK_COMPILER_OUTPUT_DIR)/report \
 342         || ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )
 343 endif
 344 
 345 jck-compiler-summary: FRC
 346         if [ -r $(JCK_COMPILER_OUTPUT_DIR)/status.txt ]; then \
 347             echo ; echo "Summary of JCK-compiler test failures" ; \
 348             cat $(JCK_COMPILER_OUTPUT_DIR)/report/text/summary.txt | \
 349                 grep -v 'Not run' | grep -v 'Passed' ; \
 350             echo ; \
 351             $(EXIT) `cat $(JCK_COMPILER_OUTPUT_DIR)/status.txt` ; \
 352         fi
 353 
 354 # Run JCK-runtime tests in -Xcompile mode
 355 # This is a special mode to test javac by compiling the tests in the JCK-runtime test suite
 356 # Normal JCK-runtime invocation belongs in the jdk/ repository.
 357 #
 358 # JCK_HOME
 359 #       Installed location of JCK: should include JCK-compiler, JCK-runtime and JCK-extras
 360 # JT_JAVA
 361 #       Version of java used to run JCK.  Should normally be the same as TESTJAVA
 362 # TESTJAVA
 363 #       Version of java to be tested.
 364 # JCK_RUNTIME_OPTIONS
 365 #       Additional options for JCK-runtime
 366 # JCK_RUNTIME_TESTDIRS
 367 #       Directories of tests to be run
 368 # JCK_RUNTIME_OUTPUT_DIR
 369 #       Where to write the results
 370 # JCK_RUNTIME_REFERENCE
 371 #       (Optional) reference results (e.g. work, report or summary.txt)
 372 #
 373 jck-runtime-tests: check-jck FRC
 374         @rm -f -r $(JCK_RUNTIME_OUTPUT_DIR)/work $(JCK_RUNTIME_OUTPUT_DIR)/report \
 375             $(JCK_RUNTIME_OUTPUT_DIR)/diff.html $(JCK_RUNTIME_OUTPUT_DIR)/status.txt
 376         @mkdir -p $(JCK_RUNTIME_OUTPUT_DIR)
 377         $(JT_JAVA)/bin/java -XX:MaxPermSize=256m -Xmx512m \
 378             -jar $(JCK_HOME)/JCK-runtime-8/lib/jtjck.jar \
 379             -v:non-pass \
 380             -r:$(JCK_RUNTIME_OUTPUT_DIR)/report \
 381             -w:$(JCK_RUNTIME_OUTPUT_DIR)/work \
 382             -jdk:$(TESTJAVA) \
 383             -Xcompile \
 384             $(JCK_RUNTIME_OPTIONS) \
 385             $(JCK_RUNTIME_TESTDIRS) \
 386         || ( $(call EXIT_IF_FATAL,$(FATAL_JCK_EXIT)) ; \
 387             echo $$status > $(JCK_RUNTIME_OUTPUT_DIR)/status.txt \
 388         )
 389 ifdef JCK_RUNTIME_REFERENCE
 390         JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JCK_RUNTIME_OUTPUT_DIR)/diff.html \
 391             $(JCK_RUNTIME_REFERENCE) $(JCK_RUNTIME_OUTPUT_DIR)/report \
 392         || ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )
 393 endif
 394 
 395 jck-runtime-summary: FRC
 396         if [ -r $(JCK_RUNTIME_OUTPUT_DIR)/status.txt ]; then \
 397             echo ; echo "Summary of JCK-runtime test failures" ; \
 398             cat $(JCK_RUNTIME_OUTPUT_DIR)/report/text/summary.txt | \
 399                 grep -v 'Not run' | grep -v 'Passed' ; \
 400             echo ; \
 401             $(EXIT) `cat $(JCK_RUNTIME_OUTPUT_DIR)/status.txt` ; \
 402         fi
 403 
 404 # Check to make sure these directories exist
 405 check-jck: $(JCK_HOME) $(PRODUCT_HOME)
 406 
 407 all-summary: FRC
 408         if [ -n "`find $(TEST_OUTPUT_DIR) -name status.txt`" ]; then
 409             echo ; echo "Summary of test failures" ; \
 410             cat `find $(TEST_OUTPUT_DIR) -name summary.txt` | \
 411                 grep -v 'Not run' | grep -v 'Passed' ; \
 412             echo ; \
 413             $(EXIT) 1
 414         fi
 415 
 416 # Bundle up the results
 417 $(JPRT_ARCHIVE_BUNDLE): FRC
 418         @rm -f $@
 419         @mkdir -p $(@D)
 420         ( cd $(TEST_OUTPUT_DIR) && zip -q -r $@ . )
 421 
 422 # Cleanup
 423 clean:
 424         rm -f $(JPRT_ARCHIVE_BUNDLE)
 425 
 426 # Used to force a target rules to run
 427 FRC:
 428 
 429 # Phony targets (e.g. these are not filenames)
 430 .PHONY: all clean \
 431         jtreg javac javadoc javah javap jdeps jtreg-tests jtreg-summary check-jtreg \
 432         jck-compiler jck-compiler-tests jck-compiler-summary \
 433         jck-runtime jck-runtime-tests jck-runtime-summary check-jck
 434 
 435 # No use of suffix rules
 436 .SUFFIXES:
 437