jdk8-mips64-public/langtools: test/Makefile@ca516bc459f6

1 #

     2 # Makefile to run jtreg and other tests

3 #

     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.

    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.

    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

    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

    75 # Root of this test area (important to use full paths in some places)

    76 TEST_ROOT := $(shell pwd $(CYGPATH) )

    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

    84 ifeq ($(PLATFORM), windows)

    85   SLASH_JAVA = J:

    86 else

    87   SLASH_JAVA = /java

    88 endif

    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

    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

   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

   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

   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

   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

   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

   158 ifdef JCK_CONCURRENCY

   159   JCK_OPTIONS += -concurrency:$(JCK_CONCURRENCY)

   160 endif

   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

   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

   189 # Default verbosity setting for jtreg

   190 JTREG_VERBOSE = fail,error,nopass

   192 # Default verbosity setting for jck

   193 JCK_VERBOSE = non-pass

   195 # Assertions: some tests show failures when assertions are enabled.

   196 # Since javac is typically loaded via the bootclassloader (either via TESTJAVA

   197 # or TESTBOOTCLASSPATH), you may need -esa to enable assertions in javac.

   198 JTREG_OPTIONS += $(ASSERTION_OPTIONS)

   199 JCK_OPTIONS += $(ASSERTION_OPTIONS:%=-vmoptions:%)

   201 # Include shared options

   202 JCK_COMPILER_OPTIONS += $(JCK_OPTIONS)

   203 JCK_RUNTIME_OPTIONS += $(JCK_OPTIONS)

   205 # Exit codes:

   206 # jtreg, jck:   0: OK, 1: tests failed, 2: tests error; 3+: SERIOUS

   207 FATAL_JTREG_EXIT = 3

   208 FATAL_JCK_EXIT = 3

   209 # jtdiff: 0: OK, 1: differences found; 2+: SERIOUS

   210 FATAL_JTDIFF_EXIT = 2

   211 #

   212 # Exit -- used for final "normal" exit from "make". Redefine to "true" to avoid

   213 # having make exit with non-zero return code.

   214 EXIT = exit

   215 # Function to exit shell if exit code of preceding command is greater than or equal

   216 # to a given level. Redefine function or preceding FATAL_*_EXIT codes as needed.

   217 EXIT_IF_FATAL = status=$$?; if [ $$status -ge $(1) ]; then exit $$status ; fi

   219 # The test directories to run

   220 DEFAULT_TESTDIRS = .

   221 TESTDIRS = $(DEFAULT_TESTDIRS)

   223 # Root of all test results

   224 TEST_OUTPUT_DIR = $(TEST_ROOT)/../build/$(PLATFORM)-$(ARCH)/test/langtools

   225 ABS_TEST_OUTPUT_DIR := \

   226 	$(shell mkdir -p $(TEST_OUTPUT_DIR); \

   227 		cd  $(TEST_OUTPUT_DIR); \

   228 		pwd $(CYGPATH))

   229 # Subdirectories for different test runs

   230 JTREG_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jtreg

   231 JCK_COMPILER_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jck-compiler

   232 JCK_RUNTIME_OUTPUT_DIR = $(ABS_TEST_OUTPUT_DIR)/jck-runtime-Xcompile

   234 # Default make rule -- warning, may take a while

   235 all: $(JPRT_CLEAN) jtreg-tests jck-compiler-tests jck-runtime-tests $(JPRT_ARCHIVE_BUNDLE) all-summary

   236 	@echo "Testing completed successfully"

   238 jtreg apt javac javadoc javah javap jdeps: $(JPRT_CLEAN) jtreg-tests $(JPRT_ARCHIVE_BUNDLE) jtreg-summary

   239 	@echo "Testing completed successfully"

   241 jck-compiler: $(JPRT_CLEAN) jck-compiler-tests $(JPRT_ARCHIVE_BUNDLE) jck-compiler-summary

   242 	@echo "Testing completed successfully"

   244 jck-runtime: $(JPRT_CLEAN) jck-runtime-tests $(JPRT_ARCHIVE_BUNDLE) jck-runtime-summary

   245 	@echo "Testing completed successfully"

   247 # for use with JPRT -testrule

   248 all:		JTREG_TESTDIRS = .

   249 jtreg:		JTREG_TESTDIRS = .

   250 apt:		JTREG_TESTDIRS = tools/apt

   251 javac: 		JTREG_TESTDIRS = tools/javac

   252 javadoc:	JTREG_TESTDIRS = tools/javadoc com/sun/javadoc

   253 javah:		JTREG_TESTDIRS = tools/javah

   254 javap:		JTREG_TESTDIRS = tools/javap

   255 jdeps:		JTREG_TESTDIRS = tools/jdeps

   257 # Run jtreg tests

   258 #

   259 # JTREG_HOME

   260 #	Installed location of jtreg

   261 # JT_JAVA

   262 #	Version of java used to run jtreg.  Should normally be the same as TESTJAVA

   263 # TESTJAVA

   264 # 	Version of java to be tested.

   265 # JTREG_VERBOSE

   266 # Verbosity setting for jtreg

   267 # JTREG_OPTIONS

   268 #	Additional options for jtreg

   269 # JTREG_TESTDIRS

   270 #	Directories of tests to be run

   271 # JTREG_OUTPUT_DIR

   272 #	Where to write the results

   273 # JTREG_REFERENCE

   274 #	(Optional) reference results (e.g. work, report or summary.txt)

   275 #

   276 jtreg_tests: jtreg-tests

   277 jtreg-tests: check-jtreg FRC

   278 	@rm -f -r $(JTREG_OUTPUT_DIR)/JTwork $(JTREG_OUTPUT_DIR)/JTreport \

   279 	    $(JTREG_OUTPUT_DIR)/diff.html $(JTREG_OUTPUT_DIR)/status.txt

   280 	@mkdir -p $(JTREG_OUTPUT_DIR)

   281 	JT_JAVA=$(JT_JAVA) $(JTREG) \

   282 	  -J-Xmx512m \

   283 	  -vmoption:-Xmx768m \

   284 	  -a -ignore:quiet $(if $(JTREG_VERBOSE),-v:$(JTREG_VERBOSE)) \

   285           -r:$(JTREG_OUTPUT_DIR)/JTreport \

   286           -w:$(JTREG_OUTPUT_DIR)/JTwork \

   287           -jdk:$(TESTJAVA) \

   288           $(JAVA_ARGS:%=-vmoption:%) \

   289 	  $(JTREG_OPTIONS) \

   290           $(JTREG_TESTDIRS) \

   291 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JTREG_EXIT)) ; \

   292 	    echo $$status > $(JTREG_OUTPUT_DIR)/status.txt \

   293 	)

   294 ifdef JTREG_REFERENCE

   295 	JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JTREG_OUTPUT_DIR)/diff.html \

   296 	    $(JTREG_REFERENCE) $(JTREG_OUTPUT_DIR)/JTreport \

   297 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )

   298 endif

   300 jtreg-summary: FRC

   301 	if [ -r $(JTREG_OUTPUT_DIR)/status.txt ]; then \

   302 	    echo ; echo "Summary of jtreg test failures" ; \

   303 	    cat $(JTREG_OUTPUT_DIR)/JTreport/text/summary.txt | \

   304 		grep -v 'Not run' | grep -v 'Passed' ; \

   305 	    echo ; \

   306 	    $(EXIT) `cat $(JTREG_OUTPUT_DIR)/status.txt` ; \

   307 	fi

   309 # Check to make sure these directories exist

   310 check-jtreg: $(PRODUCT_HOME) $(JTREG)

   313 # Run JCK-compiler tests

   314 #

   315 # JCK_HOME

   316 #	Installed location of JCK: should include JCK-compiler, and JCK-extras

   317 #       Default is JCK 8.

   318 # JT_JAVA

   319 #	Version of java used to run JCK.  Should normally be the same as TESTJAVA

   320 #       Default is JDK 7

   321 # TESTJAVA

   322 # 	Version of java to be tested.

   323 # JCK_VERBOSE

   324 #	Verbosity setting for jtjck

   325 # JCK_COMPILER_OPTIONS

   326 #	Additional options for JCK-compiler

   327 # JCK_COMPILER_TESTDIRS

   328 #	Directories of tests to be run

   329 # JCK_COMPILER_OUTPUT_DIR

   330 #	Where to write the results

   331 # JCK_COMPILER_REFERENCE

   332 #	(Optional) reference results (e.g. work, report or summary.txt)

   333 #

   334 jck-compiler-tests: check-jck FRC

   335 	@rm -f -r $(JCK_COMPILER_OUTPUT_DIR)/work $(JCK_COMPILER_OUTPUT_DIR)/report \

   336 	    $(JCK_COMPILER_OUTPUT_DIR)/diff.html $(JCK_COMPILER_OUTPUT_DIR)/status.txt

   337 	@mkdir -p $(JCK_COMPILER_OUTPUT_DIR)

   338 	$(JT_JAVA)/bin/java -Xmx512m \

   339 	    -jar $(JCK_HOME)/JCK-compiler-8/lib/jtjck.jar \

   340 	    $(if $(JCK_VERBOSE),-v:$(JCK_VERBOSE)) \

   341             -r:$(JCK_COMPILER_OUTPUT_DIR)/report \

   342             -w:$(JCK_COMPILER_OUTPUT_DIR)/work \

   343             -jdk:$(TESTJAVA) \

   344 	    $(JCK_COMPILER_OPTIONS) \

   345             $(JCK_COMPILER_TESTDIRS) \

   346 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JCK_EXIT)) ; \

   347 	    echo $$status > $(JCK_COMPILER_OUTPUT_DIR)/status.txt \

   348 	)

   349 ifdef JCK_COMPILER_REFERENCE

   350 	JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JCK_COMPILER_OUTPUT_DIR)/diff.html \

   351 	    $(JCK_COMPILER_REFERENCE) $(JCK_COMPILER_OUTPUT_DIR)/report \

   352 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )

   353 endif

   355 jck-compiler-summary: FRC

   356 	if [ -r $(JCK_COMPILER_OUTPUT_DIR)/status.txt ]; then \

   357 	    echo ; echo "Summary of JCK-compiler test failures" ; \

   358 	    cat $(JCK_COMPILER_OUTPUT_DIR)/report/text/summary.txt | \

   359 		grep -v 'Not run' | grep -v 'Passed' ; \

   360 	    echo ; \

   361 	    $(EXIT) `cat $(JCK_COMPILER_OUTPUT_DIR)/status.txt` ; \

   362 	fi

   364 # Run JCK-runtime tests in -Xcompile mode

   365 # This is a special mode to test javac by compiling the tests in the JCK-runtime test suite

   366 # Normal JCK-runtime invocation belongs in the jdk/ repository.

   367 #

   368 # JCK_HOME

   369 #	Installed location of JCK: should include JCK-compiler, JCK-runtime and JCK-extras

   370 # JT_JAVA

   371 #	Version of java used to run JCK.  Should normally be the same as TESTJAVA

   372 # TESTJAVA

   373 # 	Version of java to be tested.

   374 # JCK_VERBOSE

   375 #	Verbosity setting for jtjck

   376 # JCK_RUNTIME_OPTIONS

   377 #	Additional options for JCK-runtime

   378 # JCK_RUNTIME_TESTDIRS

   379 #	Directories of tests to be run

   380 # JCK_RUNTIME_OUTPUT_DIR

   381 #	Where to write the results

   382 # JCK_RUNTIME_REFERENCE

   383 #	(Optional) reference results (e.g. work, report or summary.txt)

   384 #

   385 jck-runtime-tests: check-jck FRC

   386 	@rm -f -r $(JCK_RUNTIME_OUTPUT_DIR)/work $(JCK_RUNTIME_OUTPUT_DIR)/report \

   387 	    $(JCK_RUNTIME_OUTPUT_DIR)/diff.html $(JCK_RUNTIME_OUTPUT_DIR)/status.txt

   388 	@mkdir -p $(JCK_RUNTIME_OUTPUT_DIR)

   389 	$(JT_JAVA)/bin/java -Xmx512m \

   390 	    -jar $(JCK_HOME)/JCK-runtime-8/lib/jtjck.jar \

   391 	    $(if $(JCK_VERBOSE),-v:$(JCK_VERBOSE)) \

   392             -r:$(JCK_RUNTIME_OUTPUT_DIR)/report \

   393             -w:$(JCK_RUNTIME_OUTPUT_DIR)/work \

   394             -jdk:$(TESTJAVA) \

   395 	    -Xcompile \

   396 	    $(JCK_RUNTIME_OPTIONS) \

   397             $(JCK_RUNTIME_TESTDIRS) \

   398 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JCK_EXIT)) ; \

   399 	    echo $$status > $(JCK_RUNTIME_OUTPUT_DIR)/status.txt \

   400 	)

   401 ifdef JCK_RUNTIME_REFERENCE

   402 	JT_JAVA=$(JT_JAVA) $(JTDIFF) -o $(JCK_RUNTIME_OUTPUT_DIR)/diff.html \

   403 	    $(JCK_RUNTIME_REFERENCE) $(JCK_RUNTIME_OUTPUT_DIR)/report \

   404 	|| ( $(call EXIT_IF_FATAL,$(FATAL_JTDIFF_EXIT)) )

   405 endif

   407 jck-runtime-summary: FRC

   408 	if [ -r $(JCK_RUNTIME_OUTPUT_DIR)/status.txt ]; then \

   409 	    echo ; echo "Summary of JCK-runtime test failures" ; \

   410 	    cat $(JCK_RUNTIME_OUTPUT_DIR)/report/text/summary.txt | \

   411 		grep -v 'Not run' | grep -v 'Passed' ; \

   412 	    echo ; \

   413 	    $(EXIT) `cat $(JCK_RUNTIME_OUTPUT_DIR)/status.txt` ; \

   414 	fi

   416 # Check to make sure these directories exist

   417 check-jck: $(JCK_HOME) $(PRODUCT_HOME)

   419 all-summary: FRC

   420 	if [ -n "`find $(TEST_OUTPUT_DIR) -name status.txt`" ]; then

   421 	    echo ; echo "Summary of test failures" ; \

   422 	    cat `find $(TEST_OUTPUT_DIR) -name summary.txt` | \

   423 		grep -v 'Not run' | grep -v 'Passed' ; \

   424 	    echo ; \

   425 	    $(EXIT) 1

   426 	fi

   428 # Bundle up the results

   429 $(JPRT_ARCHIVE_BUNDLE): FRC

   430 	@rm -f $@

   431 	@mkdir -p $(@D)

   432 	( cd $(TEST_OUTPUT_DIR) && zip -q -r $@ . )

   434 # Cleanup

   435 clean:

   436 	rm -f $(JPRT_ARCHIVE_BUNDLE)

   438 # Used to force a target rules to run

   439 FRC:

   441 # Phony targets (e.g. these are not filenames)

   442 .PHONY: all clean \

   443 	jtreg javac javadoc javah javap jdeps jtreg-tests jtreg-summary check-jtreg \

   444 	jck-compiler jck-compiler-tests jck-compiler-summary \

   445 	jck-runtime jck-runtime-tests jck-runtime-summary check-jck

   447 # No use of suffix rules

   448 .SUFFIXES:

Mercurial > jdk8-mips64-public > langtools / file revision

test/Makefile@ca516bc459f6

test/Makefile